$treeview $search $mathjax
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