DemandParserHelper.hpp

Go to the documentation of this file.

#ifndef __TRADEMGEN_CMD_DEMANDPARSERHELPER_HPP
#define __TRADEMGEN_CMD_DEMANDPARSERHELPER_HPP

// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <string>
// STDAIR
#include <stdair/command/CmdAbstract.hpp>
// SEvMgr
#include <sevmgr/SEVMGR_Types.hpp>
// TRADEMGEN
#include <trademgen/TRADEMGEN_Types.hpp>
#include <trademgen/basic/BasParserTypes.hpp>
#include <trademgen/bom/DemandStruct.hpp>

// Forward declarations
namespace stdair {
  struct RandomGeneration;
}

namespace TRADEMGEN {

  namespace DemandParserHelper {
    
    // ///////////////////////////////////////////////////////////////////
    //  Semantic actions
    // ///////////////////////////////////////////////////////////////////
    struct ParserSemanticAction {
      ParserSemanticAction (DemandStruct&);
      DemandStruct& _demand;
    };
  
    struct storePrefDepDateRangeStart : public ParserSemanticAction {
      storePrefDepDateRangeStart (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

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

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

    struct storeOrigin : public ParserSemanticAction {
      storeOrigin (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeDestination : public ParserSemanticAction {
      storeDestination (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };

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

    struct storeDemandMean : public ParserSemanticAction {
      storeDemandMean (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeDemandStdDev : public ParserSemanticAction {
      storeDemandStdDev (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeDemandChangeFeeProb : public ParserSemanticAction {
      storeDemandChangeFeeProb (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeDemandChangeFeeDisutility : public ParserSemanticAction {
      storeDemandChangeFeeDisutility (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeDemandNonRefundableProb : public ParserSemanticAction {
      storeDemandNonRefundableProb (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeDemandNonRefundableDisutility : public ParserSemanticAction {
      storeDemandNonRefundableDisutility (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storePosCode : public ParserSemanticAction {
      storePosCode (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storePosProbMass : public ParserSemanticAction {
      storePosProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeChannelCode : public ParserSemanticAction {
      storeChannelCode (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeChannelProbMass : public ParserSemanticAction {
      storeChannelProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeTripCode : public ParserSemanticAction {
      storeTripCode (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeTripProbMass : public ParserSemanticAction {
      storeTripProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeStayCode : public ParserSemanticAction {
      storeStayCode (DemandStruct&);
      void operator() (unsigned int iInteger) const;
    };
  
    struct storeStayProbMass : public ParserSemanticAction {
      storeStayProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeFFCode : public ParserSemanticAction {
      storeFFCode (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };
  
    struct storeFFProbMass : public ParserSemanticAction {
      storeFFProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storePrefDepTime : public ParserSemanticAction {
      storePrefDepTime (DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
    };    
    
    struct storePrefDepTimeProbMass : public ParserSemanticAction {
      storePrefDepTimeProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeWTP : public ParserSemanticAction {
      storeWTP (DemandStruct&);
      void operator() (double iReal) const;
    };
    
    struct storeTimeValue : public ParserSemanticAction {
      storeTimeValue (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeTimeValueProbMass : public ParserSemanticAction {
      storeTimeValueProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct storeDTD : public ParserSemanticAction {
      storeDTD (DemandStruct&);
      void operator() (unsigned int iInteger) const;
    };    
    
    struct storeDTDProbMass : public ParserSemanticAction {
      storeDTDProbMass (DemandStruct&);
      void operator() (double iReal) const;
    };
  
    struct doEndDemand : public ParserSemanticAction {
      doEndDemand (SEVMGR::SEVMGR_ServicePtr_T, stdair::RandomGeneration&,
                   const POSProbabilityMass_T&, DemandStruct&);
      void operator() (iterator_t iStr, iterator_t iStrEnd) const;
      SEVMGR::SEVMGR_ServicePtr_T _sevmgrServicePtr;
      stdair::RandomGeneration& _uniformGenerator;
      const POSProbabilityMass_T& _posProbabilityMass;
    };
  

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

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

      DemandParser (SEVMGR::SEVMGR_ServicePtr_T, stdair::RandomGeneration&,
                    const POSProbabilityMass_T&, DemandStruct&);

      template <typename ScannerT>
      struct definition {
        definition (DemandParser const& self);
        
        // Instantiation of rules
        boost::spirit::classic::rule<ScannerT> demand_list,
          not_to_be_parsed, demand, demand_end, pref_dep_date_range,
          date, dow, origin, destination, pref_cabin, demand_params,
          pos_dist, pos_pair, pos_code, pos_share,
          channel_dist, channel_pair, channel_code, channel_share,
          trip_dist, trip_pair, trip_code, trip_share,
          stay_dist, stay_pair, stay_share,
          ff_dist, ff_pair, ff_code, ff_share,
          change_fees,
          non_refundable,
          pref_dep_time_dist, pref_dep_time_pair, pref_dep_time_share, time,
          wtp,
          time_value_dist, time_value_pair, time_value_share,
          dtd_dist, dtd_pair, dtd_share;

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

      // Parser Context
      SEVMGR::SEVMGR_ServicePtr_T _sevmgrServicePtr;
      stdair::RandomGeneration& _uniformGenerator;
      const POSProbabilityMass_T& _posProbabilityMass;
      DemandStruct& _demand;
    };

  }


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

  class DemandFileParser : public stdair::CmdAbstract {
  public:
    DemandFileParser (SEVMGR::SEVMGR_ServicePtr_T, stdair::RandomGeneration&,
                      const POSProbabilityMass_T&,
                      const stdair::Filename_T& iDemandInputFilename);

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

    iterator_t _startIterator;
      
    iterator_t _endIterator;
      
    SEVMGR::SEVMGR_ServicePtr_T _sevmgrServicePtr;

    stdair::RandomGeneration& _uniformGenerator;

    const POSProbabilityMass_T& _posProbabilityMass;

    DemandStruct _demand;
  };
    
}
#endif // __TRADEMGEN_CMD_DEMANDPARSERHELPER_HPP