$treeview $search $mathjax
AirRAC Logo  1.00.0
$projectbrief
$projectbrief
$searchbox

YieldRuleGenerator.cpp

Go to the documentation of this file.
00001 // //////////////////////////////////////////////////////////////////////
00002 // Import section
00003 // //////////////////////////////////////////////////////////////////////
00004 // STL
00005 #include <cassert>
00006 // StdAir
00007 #include <stdair/bom/BomManager.hpp>
00008 #include <stdair/bom/BomRoot.hpp>
00009 #include <stdair/bom/AirportPair.hpp>
00010 #include <stdair/bom/PosChannel.hpp>
00011 #include <stdair/bom/DatePeriod.hpp>
00012 #include <stdair/bom/TimePeriod.hpp>
00013 #include <stdair/bom/YieldFeatures.hpp>
00014 #include <stdair/bom/AirlineClassList.hpp>
00015 #include <stdair/factory/FacBomManager.hpp>
00016 #include <stdair/service/Logger.hpp>
00017 // AirRAC
00018 #include <airrac/bom/YieldRuleStruct.hpp>
00019 #include <airrac/command/YieldRuleGenerator.hpp>
00020 
00021 namespace AIRRAC {
00022 
00023   // //////////////////////////////////////////////////////////////////////
00024   void YieldRuleGenerator::
00025   createAirportPair (stdair::BomRoot& ioBomRoot,
00026                      const YieldRuleStruct& iYieldRuleStruct) {
00027 
00028     // Set the airport-pair primary key.
00029     const stdair::AirportCode_T& lBoardPoint = iYieldRuleStruct.getOrigin ();
00030     const stdair::AirportCode_T& lOffPoint = iYieldRuleStruct.getDestination ();
00031     const stdair::AirportPairKey lAirportPairKey (lBoardPoint, lOffPoint);
00032 
00033     // Check that the airport-pair object is not already existing. If an
00034     // airport-pair object with the same key has not already been created,
00035     // create it and link it to the ioBomRoot object.
00036     stdair::AirportPair* lAirportPair_ptr = stdair::BomManager::
00037       getObjectPtr<stdair::AirportPair> (ioBomRoot, lAirportPairKey.toString());
00038     if (lAirportPair_ptr == NULL) {
00039       lAirportPair_ptr = &stdair::FacBom<stdair::AirportPair>::
00040         instance().create (lAirportPairKey);
00041       stdair::FacBomManager::addToListAndMap (ioBomRoot, *lAirportPair_ptr);
00042       stdair::FacBomManager::linkWithParent (ioBomRoot, *lAirportPair_ptr);
00043     }
00044     // Sanity check.
00045     assert (lAirportPair_ptr != NULL);
00046 
00047     stdair::AirportPair& lAirportPair = *lAirportPair_ptr;
00048     // Generate the date-period object corresponding to the given
00049     // yieldRule.  
00050     createDateRange (lAirportPair, iYieldRuleStruct);
00051     
00052   }
00053 
00054 
00055   // //////////////////////////////////////////////////////////////////////
00056   void YieldRuleGenerator::
00057   createDateRange (stdair::AirportPair& iAirportPair,
00058                    const YieldRuleStruct& iYieldRuleStruct) {
00059 
00060     // Create the yield date-period primary key.
00061     const stdair::Date_T& lDateRangeStart = 
00062       iYieldRuleStruct.getDateRangeStart ();
00063     const stdair::Date_T& lDateRangeEnd = 
00064       iYieldRuleStruct.getDateRangeEnd ();
00065     const stdair::DatePeriod_T lDatePeriod (lDateRangeStart, lDateRangeEnd); 
00066     const stdair::DatePeriodKey lYieldDatePeriodKey (lDatePeriod);
00067 
00068     // Check that the date-period object is not already existing.
00069     // If a date-period object with the same key has not already been
00070     // created, create it and link it to the airport-pair object.
00071     stdair::DatePeriod* lYieldDatePeriod_ptr = stdair::BomManager::
00072       getObjectPtr<stdair::DatePeriod> (iAirportPair, 
00073                                         lYieldDatePeriodKey.toString());
00074     if (lYieldDatePeriod_ptr == NULL) {
00075       lYieldDatePeriod_ptr = &stdair::FacBom<stdair::DatePeriod>::
00076         instance().create (lYieldDatePeriodKey);
00077       stdair::FacBomManager::
00078         addToListAndMap (iAirportPair, *lYieldDatePeriod_ptr);
00079       stdair::FacBomManager::
00080         linkWithParent (iAirportPair, *lYieldDatePeriod_ptr);
00081     }
00082     // Sanity check.
00083     assert (lYieldDatePeriod_ptr != NULL);
00084 
00085     stdair::DatePeriod& lDateRange = *lYieldDatePeriod_ptr;
00086     // Generate the point_of_sale-channel object corresponding to
00087     // the given yieldRule.
00088     createPOSChannel (lDateRange, iYieldRuleStruct);
00089     
00090   }
00091 
00092   // //////////////////////////////////////////////////////////////////////
00093   void YieldRuleGenerator::
00094   createPOSChannel (stdair::DatePeriod& iDatePeriod,
00095                     const YieldRuleStruct& iYieldRuleStruct) {
00096 
00097     // Create the point-of-sale-channel primary key.
00098     const stdair::CityCode_T& lPoS = iYieldRuleStruct.getPOS ();
00099     const stdair::ChannelLabel_T& lChannel = iYieldRuleStruct.getChannel ();
00100     const stdair::PosChannelKey lYieldPosChannelKey (lPoS, lChannel);
00101 
00102     // Check that the point_of_sale-channel object is not already existing.
00103     // If a point_of_sale-channel object with the same key has not already
00104     // been created, create it and link it to the date-period object.     
00105     stdair::PosChannel* lYieldPosChannel_ptr = stdair::BomManager::
00106       getObjectPtr<stdair::PosChannel> (iDatePeriod,
00107                                         lYieldPosChannelKey.toString());
00108     if (lYieldPosChannel_ptr == NULL) {
00109       lYieldPosChannel_ptr = &stdair::FacBom<stdair::PosChannel>::
00110         instance().create (lYieldPosChannelKey);
00111       stdair::FacBomManager::
00112         addToListAndMap (iDatePeriod, *lYieldPosChannel_ptr);
00113       stdair::FacBomManager::
00114         linkWithParent (iDatePeriod, *lYieldPosChannel_ptr);
00115     }
00116     // Sanity check.
00117     assert (lYieldPosChannel_ptr != NULL);
00118 
00119     stdair::PosChannel& lPosChannel = *lYieldPosChannel_ptr;
00120     // Generate the time-period object corresponding to the given
00121     // yieldRule.
00122     createTimeRange (lPosChannel, iYieldRuleStruct);
00123 
00124   }
00125 
00126   // //////////////////////////////////////////////////////////////////////
00127   void YieldRuleGenerator::
00128   createTimeRange (stdair::PosChannel& iPosChannel,
00129                    const YieldRuleStruct& iYieldRuleStruct) {
00130    
00131     // Create the yield time-period primary key.
00132     const stdair::Time_T& lTimeRangeStart
00133       = iYieldRuleStruct.getTimeRangeStart ();
00134     const stdair::Time_T& lTimeRangeEnd
00135       = iYieldRuleStruct.getTimeRangeEnd ();
00136     const stdair::TimePeriodKey lYieldTimePeriodKey (lTimeRangeStart,
00137                                                     lTimeRangeEnd);
00138 
00139     // Check that the time-period object is not already existing.
00140     // If a time-period object with the same key has not already been
00141     // created, create it and link it to the point_of_sale-channel object.      
00142     stdair::TimePeriod* lYieldTimePeriod_ptr = stdair::BomManager::
00143       getObjectPtr<stdair::TimePeriod> (iPosChannel, 
00144                                         lYieldTimePeriodKey.toString());
00145     if (lYieldTimePeriod_ptr == NULL) {
00146       lYieldTimePeriod_ptr = &stdair::FacBom<stdair::TimePeriod>::
00147         instance().create (lYieldTimePeriodKey);
00148       stdair::FacBomManager::
00149         addToListAndMap (iPosChannel, *lYieldTimePeriod_ptr);
00150       stdair::FacBomManager::
00151         linkWithParent (iPosChannel, *lYieldTimePeriod_ptr);
00152     }
00153     // Sanity check.
00154     assert (lYieldTimePeriod_ptr != NULL);
00155 
00156     stdair::TimePeriod& lTimeRange = *lYieldTimePeriod_ptr;
00157     // Generate the yield-features object corresponding to the given
00158     // yieldRule.
00159     createYieldFeatures (lTimeRange, iYieldRuleStruct);
00160 
00161   }
00162 
00163   // //////////////////////////////////////////////////////////////////////
00164   void YieldRuleGenerator::
00165   createYieldFeatures (stdair::TimePeriod& iTimePeriod,
00166                       const YieldRuleStruct& iYieldRuleStruct) {
00167   
00168     // Create the yield-features primary key.
00169     const stdair::TripType_T& lTripType = iYieldRuleStruct.getTripType ();
00170     stdair::CabinCode_T lCabinCode = iYieldRuleStruct.getCabinCode ();
00171     const stdair::YieldFeaturesKey lYieldFeaturesKey (lTripType, lCabinCode);
00172 
00173     // Check that the yield features object is not already existing.
00174     // If a yield features object with the same key has not already been
00175     // created, create it and link it to the time-period object.     
00176     stdair::YieldFeatures* lYieldFeatures_ptr = stdair::BomManager::
00177       getObjectPtr<stdair::YieldFeatures > (iTimePeriod,
00178                                             lYieldFeaturesKey.toString());
00179     if (lYieldFeatures_ptr == NULL) {
00180       lYieldFeatures_ptr = &stdair::FacBom<stdair::YieldFeatures>::
00181         instance().create (lYieldFeaturesKey);
00182       stdair::FacBomManager::
00183         addToListAndMap (iTimePeriod, *lYieldFeatures_ptr);
00184       stdair::FacBomManager::
00185         linkWithParent (iTimePeriod, *lYieldFeatures_ptr);
00186     }
00187     // Sanity check.
00188     assert (lYieldFeatures_ptr != NULL);
00189 
00190     stdair::YieldFeatures& lYieldFeatures = *lYieldFeatures_ptr;
00191     // Generate the airline-class list object corresponding to the
00192     // given yieldRule
00193     createAirlineClassList (lYieldFeatures, iYieldRuleStruct);
00194 
00195   }
00196 
00197   // //////////////////////////////////////////////////////////////////////
00198   void YieldRuleGenerator::
00199   createAirlineClassList (stdair::YieldFeatures& iYieldFeatures,
00200                           const YieldRuleStruct& iYieldRuleStruct) {
00201 
00202     // Create the AirlineClassList primary key.
00203     const unsigned int lAirlineListSize =
00204       iYieldRuleStruct.getAirlineListSize();
00205     const unsigned int lClassCodeListSize =
00206       iYieldRuleStruct.getClassCodeListSize();
00207     assert (lAirlineListSize == lClassCodeListSize);
00208     const stdair::AirlineClassListKey
00209       lAirlineClassListKey (iYieldRuleStruct.getAirlineList() ,
00210                             iYieldRuleStruct.getClassCodeList());
00211     const stdair::Yield_T& lYield = iYieldRuleStruct.getYield ();
00212 
00213     // Create the airline class list object and link it to the yieldures
00214     // object.    
00215     stdair::AirlineClassList* lAirlineClassList_ptr =
00216       &stdair::FacBom<stdair::AirlineClassList>::instance().
00217       create(lAirlineClassListKey);
00218     lAirlineClassList_ptr->setYield (lYield);
00219     stdair::FacBomManager::addToListAndMap (iYieldFeatures,
00220                                             *lAirlineClassList_ptr); 
00221     stdair::FacBomManager::linkWithParent (iYieldFeatures,
00222                                            *lAirlineClassList_ptr);
00223   }
00224         
00225 }
00226