AirportPairKey lAirportPairKey ("SIN", "BKK");
AirportPair& lSINBKKAirportPair =
const Date_T lDateRangeStart (2010, boost::gregorian::Mar, 01);
const Date_T lDateRangeEnd (2010, boost::gregorian::Mar, 31);
const DatePeriod_T lDateRange (lDateRangeStart, lDateRangeEnd);
const DatePeriodKey lDatePeriodKey (lDateRange);
DatePeriod& lSINBKKDatePeriod =
PosChannelKey lPosChannelKey ("SIN","IN");
PosChannel& lSINPosChannel =
const Time_T lTimeRangeStart (0, 0, 0);
const Time_T lTimeRangeEnd (23, 0, 0);
const TimePeriodKey lFareTimePeriodKey (lTimeRangeStart,
lTimeRangeEnd);
TimePeriod& lSINBKKFareTimePeriod =
FareFeatures& lSINBKKFareFeatures =
lSQAirlineCodeList.push_back ("SQ");
lYClassCodeList.push_back ("Y");
const AirlineClassListKey lSQAirlineYClassListKey (lSQAirlineCodeList,
lYClassCodeList);
lMClassCodeList.push_back ("M");
const AirlineClassListKey lSQAirlineMClassListKey (lSQAirlineCodeList,
lMClassCodeList);
AirlineClassList& lSQAirlineYClassList =
lSQAirlineYClassList.setFare(700);
AirlineClassList& lSQAirlineMClassList =
lSQAirlineMClassList.setFare(500);
lAirportPairKey = AirportPairKey ("BKK", "HKG");
AirportPair& lBKKHKGAirportPair =
DatePeriod& lBKKHKGDatePeriod =
lPosChannelKey = PosChannelKey("BKK","IN");
PosChannel& lBKKPosChannel =
TimePeriod& lBKKHKGFareTimePeriod =
FareFeatures& lBKKHKGFareFeatures =
lCXAirlineCodeList.push_back ("CX");
const AirlineClassListKey lCXAirlineYClassListKey (lCXAirlineCodeList,
lYClassCodeList);
const AirlineClassListKey lCXAirlineMClassListKey (lCXAirlineCodeList,
lMClassCodeList);
AirlineClassList& lCXAirlineYClassList =
lCXAirlineYClassList.setFare(700);
AirlineClassList& lCXAirlineMClassList =
lCXAirlineMClassList.setFare(500);
lAirportPairKey = AirportPairKey ("SIN", "HKG");
AirportPair& lSINHKGAirportPair =
DatePeriod& lSINHKGDatePeriod =
lPosChannelKey = PosChannelKey("SIN","IN");
PosChannel& lOnDSINPosChannel =
TimePeriod& lSINHKGFareTimePeriod =
FareFeatures& lSINHKGFareFeatures =
lSQ_CXAirlineCodeList.push_back ("SQ");
lSQ_CXAirlineCodeList.push_back ("CX");
lY_YClassCodeList.push_back ("Y");
lY_YClassCodeList.push_back ("Y");
const AirlineClassListKey lSQ_CXAirlineYClassListKey (lSQ_CXAirlineCodeList,
lY_YClassCodeList);
lM_MClassCodeList.push_back ("M");
lM_MClassCodeList.push_back ("M");
const AirlineClassListKey lSQ_CXAirlineMClassListKey (lSQ_CXAirlineCodeList,
lM_MClassCodeList);
AirlineClassList& lSQ_CXAirlineYClassList =
lSQ_CXAirlineYClassList.setFare(1200);
lSQ_CXAirlineYClassList);
lSQ_CXAirlineYClassList);
AirlineClassList& lSQ_CXAirlineMClassList =
lSQ_CXAirlineMClassList.setFare(850);
lSQ_CXAirlineMClassList);
lSQ_CXAirlineMClassList);
PosChannel& lRAC_SINBKKPosChannel =
const TimePeriodKey lYieldTimePeriodKey (lTimeRangeStart,
lTimeRangeEnd);
TimePeriod& lSINBKKYieldTimePeriod =
lSINBKKYieldTimePeriod);
lSINBKKYieldTimePeriod);
YieldFeatures& lSINBKKYieldFeatures =
lSINBKKYieldFeatures);
lSINBKKYieldFeatures);
AirlineClassList& lRAC_SQAirlineYClassList =
lRAC_SQAirlineYClassList.setYield(700);
lRAC_SQAirlineYClassList);
lRAC_SQAirlineYClassList);
AirlineClassList& lRAC_SQAirlineMClassList =
lRAC_SQAirlineMClassList.setYield(500);
lRAC_SQAirlineMClassList);
lRAC_SQAirlineMClassList);
PosChannel& lRAC_BKKHKGPosChannel =
TimePeriod& lBKKHKGYieldTimePeriod =
lBKKHKGYieldTimePeriod);
lBKKHKGYieldTimePeriod);
YieldFeatures& lBKKHKGYieldFeatures =
lBKKHKGYieldFeatures);
lBKKHKGYieldFeatures);
AirlineClassList& lRAC_CXAirlineYClassList =
lRAC_CXAirlineYClassList.setYield(700);
lRAC_CXAirlineYClassList);
lRAC_CXAirlineYClassList);
AirlineClassList& lRAC_CXAirlineMClassList =
lRAC_CXAirlineMClassList.setYield(500);
lRAC_CXAirlineMClassList);
lRAC_CXAirlineMClassList);
PosChannel& lRAC_SINHKGChannel =
TimePeriod& lSINHKGYieldTimePeriod =
YieldFeatures& lSINHKGYieldFeatures =
lSINHKGYieldFeatures);
lSINHKGYieldFeatures);
AirlineClassList& lRAC_SQ_CXAirlineYClassList =
lRAC_SQ_CXAirlineYClassList.setYield(1200);
lRAC_SQ_CXAirlineYClassList);
lRAC_SQ_CXAirlineYClassList);
AirlineClassList& lRAC_SQ_CXAirlineMClassList =
lRAC_SQ_CXAirlineMClassList.setYield(850);
lRAC_SQ_CXAirlineMClassList);
lRAC_SQ_CXAirlineMClassList);
}
}
if (hasInventoryList == true) {
for (InventoryList_T::const_iterator itInv = lInventoryList.begin();
itInv != lInventoryList.end(); ++itInv) {
const Inventory* lInv_ptr = *itInv;
assert (lInv_ptr != NULL);
Inventory& lCloneInventory = cloneInventory (*lInv_ptr, ioCloneBomRoot);
}
}
const bool hastAirportPairList =
if (hastAirportPairList == true) {
for (AirportPairList_T::const_iterator itAirportPair =
lAirportPairList.begin();
itAirportPair != lAirportPairList.end(); ++itAirportPair) {
const AirportPair* lAirportPair_ptr = *itAirportPair;
assert (lAirportPair_ptr != NULL);
AirportPair& lCloneAirportPair = cloneAirportPair (*lAirportPair_ptr);
}
}
}
Inventory& lCloneInventory =
if (hasFlighDateList == true) {
for (FlightDateList_T::const_iterator itFD = lFlightDateList.begin();
itFD != lFlightDateList.end(); ++itFD) {
const FlightDate* lFD_ptr = *itFD;
assert (lFD_ptr != NULL);
FlightDate& lCloneFD = cloneFlightDate (*lFD_ptr);
}
}
if (hasPartnerList == true) {
for (InventoryList_T::const_iterator itInv =
lPartnerInventoryList.begin();
itInv != lPartnerInventoryList.end(); ++itInv) {
const Inventory* lInv_ptr = *itInv;
assert (lInv_ptr != NULL);
Inventory& lClonePartnerInventory = cloneInventory (*lInv_ptr,
ioCloneBomRoot);
lClonePartnerInventory);
lClonePartnerInventory);
}
}
if (hasOnDList == true){
for (OnDDateList_T::const_iterator itOnD = lOnDDateList.begin();
itOnD != lOnDDateList.end(); ++itOnD) {
const OnDDate* lOnDDate_ptr = *itOnD;
assert (lOnDDate_ptr != NULL);
OnDDate& lCloneOnDDate = cloneOnDDate (*lOnDDate_ptr);
}
}
const bool hasFlightPeriodList =
if (hasFlightPeriodList == true) {
for (FlightPeriodList_T::const_iterator itFlightPeriod =
lFlightPeriodList.begin();
itFlightPeriod != lFlightPeriodList.end(); ++itFlightPeriod) {
const FlightPeriod* lFlightPeriod_ptr = *itFlightPeriod;
assert (lFlightPeriod_ptr != NULL);
FlightPeriod& lCloneFlightPeriod = cloneFlightPeriod (*lFlightPeriod_ptr);
}
}
const AirlineFeature* lAirlineFeature_ptr =
iInventory.getAirlineCode());
if (lAirlineFeature_ptr != NULL) {
AirlineFeature& lCloneAirlineFeature =
cloneAirlineFeature (*lAirlineFeature_ptr);
}
return lCloneInventory;
}
AirlineFeature& lCloneAirlineFeature =
return lCloneAirlineFeature;
}
OnDDate& lCloneOnDDate =
return lCloneOnDDate;
}
FlightDate& lCloneFlightDate =
if (hasLegDateList == true) {
for (LegDateList_T::const_iterator itLD = lLegDateList.begin();
itLD != lLegDateList.end(); ++itLD) {
const LegDate* lLD_ptr = *itLD;
assert (lLD_ptr != NULL);
LegDate& lCloneLegDate = cloneLegDate (*lLD_ptr);
}
}
const bool hasSegmentDateList =
if (hasSegmentDateList == true) {
for (SegmentDateList_T::const_iterator itSD = lSegmentDateList.begin();
itSD != lSegmentDateList.end(); ++itSD) {
const SegmentDate* lSD_ptr = *itSD;
assert (lSD_ptr != NULL);
SegmentDate& lCloneSegmentDate = cloneSegmentDate (*lSD_ptr);
}
}
return lCloneFlightDate;
}
LegDate& lCloneLegDate =
if (hasLegCabinList == true) {
for (LegCabinList_T::const_iterator itLC = lLegCabinList.begin();
itLC != lLegCabinList.end(); ++itLC) {
const LegCabin* lLC_ptr = *itLC;
assert (lLC_ptr != NULL);
LegCabin& lCloneLegCabin = cloneLegCabin (*lLC_ptr);
}
}
return lCloneLegDate;
}
LegCabin& lCloneLegCabin =
if (hasBucketList == true) {
for (BucketList_T::const_iterator itBucket = lBucketList.begin();
itBucket != lBucketList.end(); ++itBucket) {
const Bucket* lBucket_ptr = *itBucket;
assert (lBucket_ptr != NULL);
Bucket& lCloneBucket = cloneBucket (*lBucket_ptr);
}
}
return lCloneLegCabin;
}
Bucket& CmdCloneBomManager::cloneBucket (
const Bucket& iBucket) {
Bucket& lCloneBucket =
return lCloneBucket;
}
SegmentDate& lCloneSegmentDate =
const bool hasSegmentCabinList =
if (hasSegmentCabinList == true) {
for (SegmentCabinList_T::const_iterator itSC = lSegmentCabinList.begin();
itSC != lSegmentCabinList.end(); ++itSC) {
const SegmentCabin* lSC_ptr = *itSC;
assert (lSC_ptr != NULL);
SegmentCabin& lCloneSegmentCabin = cloneSegmentCabin (*lSC_ptr);
linkBookingClassesWithSegment (lCloneSegmentDate,
lCloneSegmentCabin);
}
}
return lCloneSegmentDate;
}
void CmdCloneBomManager::
linkBookingClassesWithSegment (
SegmentDate& iCloneSegmentDate,
const bool hasFareFamilyList =
if (hasFareFamilyList == true) {
for (FareFamilyList_T::const_iterator itCloneFF = lCloneFFList.begin();
itCloneFF != lCloneFFList.end(); ++itCloneFF) {
const FareFamily* lCloneFF_ptr = *itCloneFF;
assert (lCloneFF_ptr != NULL);
const bool hasBookingClasslist =
if (hasBookingClasslist == true) {
for (BookingClassList_T::const_iterator itCloneBC =
lCloneBCList.begin();
itCloneBC != lCloneBCList.end(); ++itCloneBC) {
const BookingClass* lCloneBC_ptr = *itCloneBC;
assert (lCloneBC_ptr != NULL);
*lCloneBC_ptr);
*lCloneBC_ptr);
}
}
}
}
}
SegmentCabin& lCloneSegmentCabin =
const bool hasFareFamilyList =
if (hasFareFamilyList == true) {
for (FareFamilyList_T::const_iterator itFF = lFareFamilyList.begin();
itFF != lFareFamilyList.end(); ++itFF) {
const FareFamily* lFF_ptr = *itFF;
assert (lFF_ptr != NULL);
FareFamily& lCloneFareFamily = cloneFareFamily (*lFF_ptr);
}
}
return lCloneSegmentCabin;
}
FareFamily& lCloneFareFamily =
const bool hasBookingClassList =
if (hasBookingClassList == true) {
for (BookingClassList_T::const_iterator itBookingClass =
lBookingClassList.begin();
itBookingClass != lBookingClassList.end(); ++itBookingClass) {
const BookingClass* lBC_ptr = *itBookingClass;
assert (lBC_ptr != NULL);
BookingClass& lCloneBookingClass = cloneBookingClass (*lBC_ptr);
}
}
return lCloneFareFamily;
}
BookingClass& lCloneBookingClass =
return lCloneBookingClass;
}
AirportPair& lCloneAirportPair =
const bool hasDatePeriodList =
if (hasDatePeriodList == true) {
for (DatePeriodList_T::const_iterator itDatePeriod =
lDatePeriodList.begin();
itDatePeriod != lDatePeriodList.end(); ++itDatePeriod) {
const DatePeriod* lDatePeriod_ptr = *itDatePeriod;
assert (lDatePeriod_ptr != NULL);
DatePeriod& lCloneDatePeriod = cloneDatePeriod (*lDatePeriod_ptr);
}
}
return lCloneAirportPair;
}
DatePeriod& lCloneDatePeriod =
const bool hasPosChannelList =
if (hasPosChannelList == true) {
for (PosChannelList_T::const_iterator itPosChannel =
lPosChannelList.begin();
itPosChannel != lPosChannelList.end(); ++itPosChannel) {
const PosChannel* lPosChannel_ptr = *itPosChannel;
assert (lPosChannel_ptr != NULL);
PosChannel& lClonePosChannel = clonePosChannel (*lPosChannel_ptr);
}
}
return lCloneDatePeriod;
}
PosChannel& lClonePosChannel =
const bool hasTimePeriodList =
if (hasTimePeriodList == true) {
for (TimePeriodList_T::const_iterator itTimePeriod =
lTimePeriodList.begin();
itTimePeriod != lTimePeriodList.end(); ++itTimePeriod) {
const TimePeriod* lTimePeriod_ptr = *itTimePeriod;
assert (lTimePeriod_ptr != NULL);
TimePeriod& lCloneTimePeriod = cloneTimePeriod (*lTimePeriod_ptr);
}
}
return lClonePosChannel;
}
TimePeriod& lCloneTimePeriod =
const bool hasFareFeaturesList =
if (hasFareFeaturesList == true) {
for (FareFeaturesList_T::const_iterator itFF = lFareFeaturesList.begin();
itFF != lFareFeaturesList.end(); ++itFF) {
const FareFeatures* lFF_ptr = *itFF;
assert (lFF_ptr != NULL);
FareFeatures& lCloneFareFeatures =
cloneFeatures<FareFeatures> (*lFF_ptr);
}
}
const bool hasYieldFeaturesList =
if (hasYieldFeaturesList == true) {
for (YieldFeaturesList_T::const_iterator itYF =
lYieldFeaturesList.begin();
itYF != lYieldFeaturesList.end(); ++itYF) {
const YieldFeatures* lYF_ptr = *itYF;
assert (lYF_ptr != NULL);
YieldFeatures& lCloneYieldFeatures =
cloneFeatures<YieldFeatures> (*lYF_ptr);
}
}
return lCloneTimePeriod;
}
template <typename FEATURE_TYPE>
FEATURE_TYPE& CmdCloneBomManager::
cloneFeatures (const FEATURE_TYPE& iFeatures) {
FEATURE_TYPE& lCloneFeatures =
const bool hasAirlineClassListList =
if (hasAirlineClassListList == true) {
for (AirlineClassListList_T::const_iterator itACList =
lAirlineClassList.begin();
itACList != lAirlineClassList.end(); ++itACList) {
const AirlineClassList* lACList_ptr = *itACList;
assert (lACList_ptr != NULL);
AirlineClassList& lCloneAirlineClassList =
cloneAirlineClassList (*lACList_ptr);
lCloneAirlineClassList);
lCloneAirlineClassList);
}
}
return lCloneFeatures;
}
AirlineClassList& lCloneAirlineClassList =
return lCloneAirlineClassList;
}
FlightPeriod& lCloneFlightPeriod =
const bool hasSegmentPeriodList =
if (hasSegmentPeriodList == true) {
for (SegmentPeriodList_T::const_iterator itSegmentPeriod =
lSegmentPeriodList.begin();
itSegmentPeriod != lSegmentPeriodList.end(); ++itSegmentPeriod) {
const SegmentPeriod* lSegmentPeriod_ptr = *itSegmentPeriod;
assert (lSegmentPeriod_ptr != NULL);
SegmentPeriod& lCloneSegmentPeriod =
cloneSegmentPeriod (*lSegmentPeriod_ptr);
lCloneSegmentPeriod);
lCloneSegmentPeriod);
}
}
return lCloneFlightPeriod;
}
SegmentPeriod& lCloneSegmentPeriod =
return lCloneSegmentPeriod;
}
}