ScheduleParserHelper.hpp

Go to the documentation of this file.

#ifndef __AIRINV_CMD_SCHEDULEPARSERHELPER_HPP
#define __AIRINV_CMD_SCHEDULEPARSERHELPER_HPP

// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <string>
// StdAir
#include <stdair/command/CmdAbstract.hpp>
// Airinv
#include <airinv/AIRINV_Types.hpp>
#include <airinv/basic/BasParserTypes.hpp>
#include <airinv/bom/FlightPeriodStruct.hpp>

// Forward declarations
namespace stdair {
  class BomRoot;
}

namespace AIRINV {

  namespace ScheduleParserHelper {
    
    // ///////////////////////////////////////////////////////////////////
    //  Semantic actions
    // ///////////////////////////////////////////////////////////////////
    struct ParserSemanticAction {
      ParserSemanticAction (FlightPeriodStruct&);
      FlightPeriodStruct& _flightPeriod;
    };
      
    struct storeAirlineCode : public ParserSemanticAction {
      storeAirlineCode (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeFlightNumber : public ParserSemanticAction {
      storeFlightNumber (FlightPeriodStruct&);
      void operator() (unsigned int iNumber) const;
    };
  
    struct storeDateRangeStart : public ParserSemanticAction {
      storeDateRangeStart (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeDateRangeEnd : public ParserSemanticAction {
      storeDateRangeEnd (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeDow : public ParserSemanticAction {
      storeDow (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeLegBoardingPoint : public ParserSemanticAction {
      storeLegBoardingPoint (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeLegOffPoint : public ParserSemanticAction {
      storeLegOffPoint (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeOperatingAirlineCode : public ParserSemanticAction {
      storeOperatingAirlineCode (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeOperatingFlightNumber : public ParserSemanticAction {
      storeOperatingFlightNumber (FlightPeriodStruct&);
      void operator() (unsigned int iNumber) const;
    };

    struct storeBoardingTime : public ParserSemanticAction {
      storeBoardingTime (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeOffTime : public ParserSemanticAction {
      storeOffTime (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeElapsedTime : public ParserSemanticAction {
      storeElapsedTime (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeLegCabinCode : public ParserSemanticAction {
      storeLegCabinCode (FlightPeriodStruct&);
      void operator() (char iChar) const;
    };
  
    struct storeCapacity : public ParserSemanticAction {
      storeCapacity (FlightPeriodStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeSegmentSpecificity : public ParserSemanticAction {
      storeSegmentSpecificity (FlightPeriodStruct&);
      void operator() (char iChar) const;
    };
  
    struct storeSegmentBoardingPoint : public ParserSemanticAction {
      storeSegmentBoardingPoint (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeSegmentOffPoint : public ParserSemanticAction {
      storeSegmentOffPoint (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeSegmentCabinCode : public ParserSemanticAction {
      storeSegmentCabinCode (FlightPeriodStruct&);
      void operator() (char iChar) const;
    };
  
    struct storeClasses : public ParserSemanticAction {
      storeClasses (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeFamilyCode : public ParserSemanticAction {
      storeFamilyCode (FlightPeriodStruct&);
      void operator() (int iCode) const;
    };
  
    struct storeFRAT5CurveKey : public ParserSemanticAction {
      storeFRAT5CurveKey (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeFFDisutilityCurveKey : public ParserSemanticAction {
      storeFFDisutilityCurveKey (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

    struct storeFClasses : public ParserSemanticAction {
      storeFClasses (FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
      
    struct doEndFlight : public ParserSemanticAction {
      doEndFlight (stdair::BomRoot&, FlightPeriodStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
      stdair::BomRoot& _bomRoot;
    };
  

    //
    //  (Boost Spirit) Grammar Definition
    //

    struct FlightPeriodParser : 
      public boost::spirit::classic::grammar<FlightPeriodParser> {

      FlightPeriodParser (stdair::BomRoot&, FlightPeriodStruct&);

      template <typename ScannerT>
      struct definition {
        definition (FlightPeriodParser const& self);

        // Instantiation of rules
        boost::spirit::classic::rule<ScannerT> flight_period_list,
          not_to_be_parsed, flight_period, flight_period_end,
          flight_key, airline_code, flight_number,
          date, dow, time, date_offset,
          leg, leg_key, operating_leg_details, leg_details, leg_cabin_details,
          segment_section, segment_key, full_segment_cabin_details,
          segment_cabin_details, full_family_cabin_details,
          family_cabin_details, generic_segment, specific_segment_list;

        boost::spirit::classic::rule<ScannerT> const& start() const;
      };

      // Parser Context
      stdair::BomRoot& _bomRoot;
      FlightPeriodStruct& _flightPeriod;
    };

  }

  //
  //  Entry class for the file parser
  //

  class FlightPeriodFileParser : public stdair::CmdAbstract {
  public:
    FlightPeriodFileParser (stdair::BomRoot& ioBomRoot,
                            const stdair::Filename_T& iFilename);

    bool generateInventories ();
      
  private:
    void init();
      
  private:
    // Attributes
    stdair::Filename_T _filename;

    iterator_t _startIterator;
      
    iterator_t _endIterator;
      
    stdair::BomRoot& _bomRoot;

    FlightPeriodStruct _flightPeriod;
  };
    
}
#endif // __AIRINV_CMD_SCHEDULEPARSERHELPER_HPP