$treeview $search $mathjax
StdAir Logo  1.00.2
$projectbrief
$projectbrief
$searchbox

C++ Class Building Sample StdAir BOM Trees

 */
// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <cassert>
#include <sstream>
// StdAir
#include <stdair/basic/BasConst_General.hpp>
#include <stdair/basic/BasConst_DefaultObject.hpp>
#include <stdair/basic/BasConst_Request.hpp>
#include <stdair/basic/BasConst_Inventory.hpp>
#include <stdair/bom/BomRetriever.hpp>
#include <stdair/bom/BomRoot.hpp>
#include <stdair/bom/Inventory.hpp>
#include <stdair/bom/AirlineFeature.hpp>
#include <stdair/bom/FlightDate.hpp>
#include <stdair/bom/LegDate.hpp>
#include <stdair/bom/LegCabin.hpp>
#include <stdair/bom/SegmentDate.hpp>
#include <stdair/bom/SegmentCabin.hpp>
#include <stdair/bom/FareFamily.hpp>
#include <stdair/bom/BookingClass.hpp>
#include <stdair/bom/AirportPair.hpp>
#include <stdair/bom/PosChannel.hpp>
#include <stdair/bom/DatePeriod.hpp>
#include <stdair/bom/TimePeriod.hpp>
#include <stdair/bom/FareFeatures.hpp>
#include <stdair/bom/YieldFeatures.hpp>
#include <stdair/bom/AirlineClassList.hpp>
#include <stdair/bom/BomManager.hpp>
#include <stdair/bom/TravelSolutionStruct.hpp>
#include <stdair/bom/BookingRequestStruct.hpp>
#include <stdair/factory/FacBomManager.hpp>
#include <stdair/factory/FacBom.hpp>
#include <stdair/command/CmdBomManager.hpp>
#include <stdair/service/Logger.hpp>
#include <stdair/bom/OnDDate.hpp>
#include <stdair/bom/SegmentPeriod.hpp>
#include <stdair/bom/FlightPeriod.hpp>

namespace stdair {

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildSampleBom (BomRoot& ioBomRoot) {

    // DEBUG
    STDAIR_LOG_DEBUG ("StdAir is building the BOM tree from built-in "
                      << "specifications.");

    // ////// Basic Bom Tree ///////
    // Build the inventory (flight-dates) and the schedule (flight period) 
    // parts.
    buildSampleInventorySchedule (ioBomRoot);

    // Build the pricing (fare rules) and revenue accounting (yields) parts.
    buildSamplePricing (ioBomRoot);

    // ////// Partnership Bom Tree ///////    
    // Build the inventory (flight-dates) and the schedule (flight period) 
    // parts.
    buildPartnershipsSampleInventoryAndRM (ioBomRoot);

    // Build the pricing (fare rules) and revenue accounting (yields) parts.
    buildPartnershipsSamplePricing (ioBomRoot);

    // Build a dummy inventory, needed by RMOL.
    buildCompleteDummyInventory (ioBomRoot);

    // ////// Fare Families Bom Tree ///////
    // Build the inventory (flight-dates) and the schedule (flight period) 
    // parts with fare families.
    buildSampleInventoryScheduleForFareFamilies (ioBomRoot);
    
    // Build the pricing (fare rules) and revenue accounting (yields) parts.
    buildSamplePricingForFareFamilies (ioBomRoot);

    // Build a dummy inventory, needed by RMOL.
    buildCompleteDummyInventoryForFareFamilies (ioBomRoot);
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildSampleInventorySchedule (BomRoot& ioBomRoot) {

    // Inventory
    // Step 0.1: Inventory level
    // Create an Inventory for BA
    const AirlineCode_T lAirlineCodeBA ("BA");
    const InventoryKey lBAKey (lAirlineCodeBA);
    Inventory& lBAInv = FacBom<Inventory>::instance().create (lBAKey);
    FacBomManager::addToListAndMap (ioBomRoot, lBAInv);
    FacBomManager::linkWithParent (ioBomRoot, lBAInv);

    // Add the airline feature object to the BA inventory
    const AirlineFeatureKey lAirlineFeatureBAKey (lAirlineCodeBA);
    AirlineFeature& lAirlineFeatureBA =
      FacBom<AirlineFeature>::instance().create (lAirlineFeatureBAKey);
    FacBomManager::setAirlineFeature (lBAInv, lAirlineFeatureBA);
    FacBomManager::linkWithParent (lBAInv, lAirlineFeatureBA);
    // Link the airline feature object with the top of the BOM tree
    FacBomManager::addToListAndMap (ioBomRoot, lAirlineFeatureBA);
    
    // Create an Inventory for AF
    const AirlineCode_T lAirlineCodeAF ("AF");
    const InventoryKey lAFKey (lAirlineCodeAF);
    Inventory& lAFInv = FacBom<Inventory>::instance().create (lAFKey);
    FacBomManager::addToListAndMap (ioBomRoot, lAFInv);
    FacBomManager::linkWithParent (ioBomRoot, lAFInv);
    
    // Add the airline feature object to the AF inventory
    const AirlineFeatureKey lAirlineFeatureAFKey (lAirlineCodeAF);
    AirlineFeature& lAirlineFeatureAF =
      FacBom<AirlineFeature>::instance().create (lAirlineFeatureAFKey);
    FacBomManager::setAirlineFeature (lAFInv, lAirlineFeatureAF);
    FacBomManager::linkWithParent (lAFInv, lAirlineFeatureAF);
    // Link the airline feature object with the top of the BOM tree
    FacBomManager::addToListAndMap (ioBomRoot, lAirlineFeatureAF);

    // BA
    // Step 0.2: Flight-date level
    // Create a FlightDate (BA9/10-JUN-2011) for BA's Inventory
    FlightNumber_T lFlightNumber = 9;
    Date_T lDate (2011, 6, 10);
    FlightDateKey lFlightDateKey (lFlightNumber, lDate);

    FlightDate& lBA9_20110610_FD =
      FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lBAInv, lBA9_20110610_FD);
    FacBomManager::linkWithParent (lBAInv, lBA9_20110610_FD);
    
    // Display the flight-date
    // STDAIR_LOG_DEBUG ("FlightDate: " << lBA9_20110610_FD.toString());
    
    // Step 0.3: Segment-date level
    // Create a first SegmentDate (LHR-SYD) for BA's Inventory
    // See http://www.britishairways.com/travel/flightinformation/public/fr_fr?&Carrier=BA&FlightNumber=0009&from=LHR&to=SYD&depDate=100611&SellingClass=O
    const AirportCode_T lLHR ("LHR");
    const AirportCode_T lSYD ("SYD");
    const DateOffset_T l1Day (1);
    const DateOffset_T l2Days (2);
    const Duration_T l2135 (21, 45, 0);
    const Duration_T l0610 (6, 10, 0);
    const Duration_T l2205 (22, 05, 0);
    SegmentDateKey lSegmentDateKey (lLHR, lSYD);

    SegmentDate& lLHRSYDSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lBA9_20110610_FD, lLHRSYDSegment);
    FacBomManager::linkWithParent (lBA9_20110610_FD, lLHRSYDSegment); 

    // Add the routing leg keys to the LHR-SYD segment.
    const std::string lBALHRRoutingLegStr = "BA;9;2011-Jun-10;LHR";
    const std::string lBABKKRoutingLegStr = "BA;9;2011-Jun-10;BKK";
    lLHRSYDSegment.addLegKey (lBALHRRoutingLegStr);
    lLHRSYDSegment.addLegKey (lBABKKRoutingLegStr);

    // Fill the SegmentDate content
    lLHRSYDSegment.setBoardingDate (lDate);
    lLHRSYDSegment.setOffDate (lDate + l2Days);
    lLHRSYDSegment.setBoardingTime (l2135);
    lLHRSYDSegment.setOffTime (l0610);
    lLHRSYDSegment.setElapsedTime (l2135);
  
    // Display the segment-date
    // STDAIR_LOG_DEBUG ("SegmentDate: " << lLHRSYDSegment);

    // Create a second SegmentDate (LHR-BKK) for BA's Inventory
    // See http://www.britishairways.com/travel/flightinformation/public/fr_fr?&Carrier=BA&FlightNumber=0009&from=LHR&to=BKK&depDate=100611&SellingClass=O
    const AirportCode_T lBKK ("BKK");
    const Duration_T l1540 (15, 40, 0);
    const Duration_T l1105 (11, 5, 0);
    lSegmentDateKey = SegmentDateKey (lLHR, lBKK);

    SegmentDate& lLHRBKKSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lBA9_20110610_FD, lLHRBKKSegment);
    FacBomManager::linkWithParent (lBA9_20110610_FD, lLHRBKKSegment); 

    // Add the routing leg key to the LHR-BKK segment.
    lLHRBKKSegment.addLegKey (lBALHRRoutingLegStr);

    // Fill the SegmentDate content
    lLHRBKKSegment.setBoardingDate (lDate);
    lLHRBKKSegment.setOffDate (lDate + l1Day);
    lLHRBKKSegment.setBoardingTime (l2135);
    lLHRBKKSegment.setOffTime (l1540);
    lLHRBKKSegment.setElapsedTime (l1105);
  
    // Display the segment-date
    // STDAIR_LOG_DEBUG ("SegmentDate: " << lLHRBKKSegment);

    // Create a third SegmentDate (BKK-SYD) for BA's Inventory
    // See http://www.britishairways.com/travel/flightinformation/public/fr_fr?&Carrier=BA&FlightNumber=0009&from=BKK&to=SYD&depDate=110611&SellingClass=O
    const Duration_T l1705 (17, 5, 0);
    const Duration_T l0905 (9, 5, 0);
    lSegmentDateKey = SegmentDateKey (lBKK, lSYD);

    SegmentDate& lBKKSYDSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lBA9_20110610_FD, lBKKSYDSegment);
    FacBomManager::linkWithParent (lBA9_20110610_FD, lBKKSYDSegment);

    // Add the routing leg key to the BKK-SYD segment.
    lBKKSYDSegment.addLegKey (lBABKKRoutingLegStr);

    // Fill the SegmentDate content
    lBKKSYDSegment.setBoardingDate (lDate + l1Day);
    lBKKSYDSegment.setOffDate (lDate + l2Days);
    lBKKSYDSegment.setBoardingTime (l1705);
    lBKKSYDSegment.setOffTime (l1540);
    lBKKSYDSegment.setElapsedTime (l0905);
  
    // Display the segment-date
    // STDAIR_LOG_DEBUG ("SegmentDate: " << lBKKSYDSegment);

    // Step 0.4: Leg-date level
    // Create a first LegDate (LHR) for BA's Inventory
    LegDateKey lLegDateKey (lLHR);

    LegDate& lLHRLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lBA9_20110610_FD, lLHRLeg);
    FacBomManager::linkWithParent (lBA9_20110610_FD, lLHRLeg);

    // Fill the LegDate content
    lLHRLeg.setOffPoint (lBKK);
    lLHRLeg.setBoardingDate (lDate);
    lLHRLeg.setOffDate (lDate + l1Day);
    lLHRLeg.setBoardingTime (l2135);
    lLHRLeg.setOffTime (l1540);
    lLHRLeg.setElapsedTime (l1105);

    // Display the leg-date
    // STDAIR_LOG_DEBUG ("LegDate: " << lLHRLeg.toString());
    
    // Create a second LegDate (BKK)
    lLegDateKey = LegDateKey (lBKK);

    LegDate& lBKKLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lBA9_20110610_FD, lBKKLeg);
    FacBomManager::linkWithParent (lBA9_20110610_FD, lBKKLeg);

    // Display the leg-date
    // STDAIR_LOG_DEBUG ("LegDate: " << lBKKLeg.toString());

    // Fill the LegDate content
    lBKKLeg.setOffPoint (lSYD);
    lBKKLeg.setBoardingDate (lDate + l1Day);
    lBKKLeg.setOffDate (lDate + l2Days);
    lBKKLeg.setBoardingTime (l1705);
    lBKKLeg.setOffTime (l1540);
    lBKKLeg.setElapsedTime (l0905);

    // Step 0.5: segment-cabin level
    // Create a SegmentCabin (Y) for the Segment LHR-BKK of BA's Inventory
    const CabinCode_T lY ("Y");
    SegmentCabinKey lYSegmentCabinKey (lY);

    SegmentCabin& lLHRBKKSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lLHRBKKSegment, lLHRBKKSegmentYCabin);
    FacBomManager::linkWithParent (lLHRBKKSegment, lLHRBKKSegmentYCabin);

    // Display the segment-cabin
    // STDAIR_LOG_DEBUG ("SegmentCabin: " << lLHRBKKSegmentYCabin.toString());

    // Create a SegmentCabin (Y) of the Segment BKK-SYD;
    SegmentCabin& lBKKSYDSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lBKKSYDSegment, lBKKSYDSegmentYCabin);
    FacBomManager::linkWithParent (lBKKSYDSegment, lBKKSYDSegmentYCabin);

     
    // Display the segment-cabin
    // STDAIR_LOG_DEBUG ("SegmentCabin: " << lBKKSYDSegmentYCabin.toString());

    // Create a SegmentCabin (Y) of the Segment LHR-SYD;
    SegmentCabin& lLHRSYDSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lLHRSYDSegment, lLHRSYDSegmentYCabin);
    FacBomManager::linkWithParent (lLHRSYDSegment, lLHRSYDSegmentYCabin);
      
    // Display the segment-cabin
    // STDAIR_LOG_DEBUG ("SegmentCabin: " << lLHRSYDSegmentYCabin.toString());

    // Step 0.6: leg-cabin level
    // Create a LegCabin (Y) for the Leg LHR-BKK on BA's Inventory
    LegCabinKey lYLegCabinKey (lY);

    LegCabin& lLHRLegYCabin =
      FacBom<LegCabin>::instance().create (lYLegCabinKey);
    FacBomManager::addToListAndMap (lLHRLeg, lLHRLegYCabin);
    FacBomManager::linkWithParent (lLHRLeg, lLHRLegYCabin);

    // Display the leg-cabin
    // STDAIR_LOG_DEBUG ("LegCabin: " << lLHRLegYCabin.toString());

    // Create a LegCabin (Y) for the Leg BKK-SYD
    LegCabin& lBKKLegYCabin =
      FacBom<LegCabin>::instance().create (lYLegCabinKey);
    FacBomManager::addToListAndMap (lBKKLeg, lBKKLegYCabin);
    FacBomManager::linkWithParent (lBKKLeg, lBKKLegYCabin);
    // Display the leg-cabin
    // STDAIR_LOG_DEBUG ("LegCabin: " << lBKKLegYCabin.toString());

    // Step 0.7: fare family level
    // Create a FareFamily (1) for the Segment LHR-BKK, cabin Y on BA's Inv
    const FamilyCode_T l1 ("EcoSaver");
    FareFamilyKey l1FareFamilyKey (l1);

    FareFamily& lLHRBKKSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lLHRBKKSegmentYCabin,
                                    lLHRBKKSegmentYCabin1Family);
    FacBomManager::linkWithParent (lLHRBKKSegmentYCabin,
                                   lLHRBKKSegmentYCabin1Family);

    // Display the booking class
    // STDAIR_LOG_DEBUG ("FareFamily: "
    //                   << lLHRBKKSegmentYCabin1Family.toString());

    // Create a FareFamily (1)  for the Segment BKK-SYD, cabin Y on BA's Inv
    FareFamily& lBKKSYDSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lBKKSYDSegmentYCabin,
                                    lBKKSYDSegmentYCabin1Family);
    FacBomManager::linkWithParent (lBKKSYDSegmentYCabin,
                                   lBKKSYDSegmentYCabin1Family);
    
    // Display the booking class
    // STDAIR_LOG_DEBUG ("FareFamily: "
    //                   << lLHRBKKSegmentYCabin1Family.toString());

    // Create a FareFamily (1)  for the Segment LHR-SYD, cabin Y on BA's Inv
    FareFamily& lLHRSYDSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lLHRSYDSegmentYCabin,
                                    lLHRSYDSegmentYCabin1Family);
    FacBomManager::linkWithParent (lLHRSYDSegmentYCabin,
                                   lLHRSYDSegmentYCabin1Family);

    // Display the booking class
    // STDAIR_LOG_DEBUG ("FareFamily: "
    //                   << lLHRBKKSegmentYCabin1Family.toString());


    // Step 0.8: booking class level
    // Create a BookingClass (Q) for the Segment LHR-BKK, cabin Y,
    // fare family 1 on BA's Inv
    const ClassCode_T lQ ("Q");
    BookingClassKey lQBookingClassKey (lQ);

    BookingClass& lLHRBKKSegmentYCabin1FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    FacBomManager::addToListAndMap (lLHRBKKSegmentYCabin1Family,
                                    lLHRBKKSegmentYCabin1FamilyQClass);
    FacBomManager::linkWithParent (lLHRBKKSegmentYCabin1Family,
                                   lLHRBKKSegmentYCabin1FamilyQClass);

    FacBomManager::addToListAndMap (lLHRBKKSegmentYCabin,
                                    lLHRBKKSegmentYCabin1FamilyQClass);
    FacBomManager::addToListAndMap (lLHRBKKSegment,
                                    lLHRBKKSegmentYCabin1FamilyQClass);

    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lLHRBKKSegmentYCabin1FamilyQClass.toString());

    // Create a BookingClass (Q) for the Segment BKK-SYD, cabin Y,
    // fare family 1 on BA's Inv
    BookingClass& lBKKSYDSegmentYCabin1FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    FacBomManager::addToListAndMap (lBKKSYDSegmentYCabin1Family,
                                    lBKKSYDSegmentYCabin1FamilyQClass);
    FacBomManager::linkWithParent (lBKKSYDSegmentYCabin1Family,
                                   lBKKSYDSegmentYCabin1FamilyQClass);
    
    FacBomManager::addToListAndMap (lBKKSYDSegmentYCabin,
                                    lBKKSYDSegmentYCabin1FamilyQClass);
    FacBomManager::addToListAndMap (lBKKSYDSegment,
                                    lBKKSYDSegmentYCabin1FamilyQClass);

    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lLHRBKKSegmentYCabin1FamilyQClass.toString());

    // Create a BookingClass (Q) for the Segment LHR-SYD, cabin Y,
    // fare family 1 on BA's Inv
    BookingClass& lLHRSYDSegmentYCabin1FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    FacBomManager::addToListAndMap (lLHRSYDSegmentYCabin1Family,
                                    lLHRSYDSegmentYCabin1FamilyQClass);
    FacBomManager::linkWithParent (lLHRSYDSegmentYCabin1Family,
                                   lLHRSYDSegmentYCabin1FamilyQClass);

    FacBomManager::addToListAndMap (lLHRSYDSegmentYCabin,
                                    lLHRSYDSegmentYCabin1FamilyQClass);
    FacBomManager::addToListAndMap (lLHRSYDSegment,
                                    lLHRSYDSegmentYCabin1FamilyQClass);

    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lLHRBKKSegmentYCabin1FamilyQClass.toString());

    
    // ////// AF ///////    
    // Step 0.2: Flight-date level
    // Create a FlightDate (AF084/20-MAR-2011) for AF's Inventory
    lFlightNumber = 84;
    lDate = Date_T (2011, 3, 20);
    lFlightDateKey = FlightDateKey (lFlightNumber, lDate);

    FlightDate& lAF084_20110320_FD =
      FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lAFInv, lAF084_20110320_FD);
    FacBomManager::linkWithParent (lAFInv, lAF084_20110320_FD);
    
    // Display the flight-date
    // STDAIR_LOG_DEBUG ("FlightDate: " << lAF084_20110320_FD.toString());

    // Step 0.3: Segment-date level
    // Create a SegmentDate (CDG-SFO) for AF's Inventory
    const AirportCode_T lCDG ("CDG");
    const AirportCode_T lSFO ("SFO");
    const Duration_T l1040 (10, 40, 0);
    const Duration_T l1250 (12, 50, 0);
    const Duration_T l1110 (11, 10, 0);
    lSegmentDateKey = SegmentDateKey (lCDG, lSFO);

    SegmentDate& lCDGSFOSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lAF084_20110320_FD, lCDGSFOSegment);
    FacBomManager::linkWithParent (lAF084_20110320_FD, lCDGSFOSegment);  

    // Add the routing leg key to the CDG-SFO segment.
    const std::string lAFCDGRoutingLegStr = "AF;84;2011-Mar-20;CDG";
    lCDGSFOSegment.addLegKey (lAFCDGRoutingLegStr);

    // Display the segment-date
    // STDAIR_LOG_DEBUG ("SegmentDate: " << lCDGSFOSegment.toString());

    // Fill the SegmentDate content
    lCDGSFOSegment.setBoardingDate (lDate);
    lCDGSFOSegment.setOffDate (lDate);
    lCDGSFOSegment.setBoardingTime (l1040);
    lCDGSFOSegment.setOffTime (l1250);
    lCDGSFOSegment.setElapsedTime (l1110);

    // Step 0.4: Leg-date level
    // Create a LegDate (CDG) for AF's Inventory
    lLegDateKey = LegDateKey (lCDG);

    LegDate& lCDGLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lAF084_20110320_FD, lCDGLeg);
    FacBomManager::linkWithParent (lAF084_20110320_FD, lCDGLeg);

    // Fill the LegDate content
    lCDGLeg.setOffPoint (lSFO);
    lCDGLeg.setBoardingDate (lDate);
    lCDGLeg.setOffDate (lDate);
    lCDGLeg.setBoardingTime (l1040);
    lCDGLeg.setOffTime (l1250);
    lCDGLeg.setElapsedTime (l1110);

    // Display the leg-date
    // STDAIR_LOG_DEBUG ("LegDate: " << lCDGLeg.toString());

    // Step 0.5: segment-cabin level
    // Create a SegmentCabin (Y) for the Segment CDG-SFO of AF's Inventory
    SegmentCabin& lCDGSFOSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lCDGSFOSegment, lCDGSFOSegmentYCabin);
    FacBomManager::linkWithParent (lCDGSFOSegment, lCDGSFOSegmentYCabin);

    // Display the segment-cabin
    // STDAIR_LOG_DEBUG ("SegmentCabin: " << lCDGSFOSegmentYCabin.toString());

    // Step 0.6: leg-cabin level
    // Create a LegCabin (Y) for the Leg CDG-SFO on AF's Inventory
    LegCabin& lCDGLegYCabin =
      FacBom<LegCabin>::instance().create (lYLegCabinKey);
    FacBomManager::addToListAndMap (lCDGLeg, lCDGLegYCabin);
    FacBomManager::linkWithParent (lCDGLeg, lCDGLegYCabin);

    // Display the leg-cabin
    // STDAIR_LOG_DEBUG ("LegCabin: " << lLHRLegYCabin.toString());

    // Step 0.7: fare family level
    // Create a fareFamily (1) for the Segment CDG-SFO, cabin Y on AF's Inv
    FareFamily& lCDGSFOSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lCDGSFOSegmentYCabin,
                                    lCDGSFOSegmentYCabin1Family);
    FacBomManager::linkWithParent (lCDGSFOSegmentYCabin,
                                   lCDGSFOSegmentYCabin1Family);

    // Display the fare family
    // STDAIR_LOG_DEBUG ("fareFamily: "
    //
    //                   << lCDGSFOSegmentYCabin1Family.toString());

    // Step 0.8: booking class level Create a BookingClass (Q) for the
    // Segment CDG-SFO, cabin Y, fare family 1 on AF's Inv
    BookingClass& lCDGSFOSegmentYCabin1FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    FacBomManager::addToListAndMap (lCDGSFOSegmentYCabin1Family,
                                    lCDGSFOSegmentYCabin1FamilyQClass);
    FacBomManager::linkWithParent (lCDGSFOSegmentYCabin1Family,
                                   lCDGSFOSegmentYCabin1FamilyQClass);

    FacBomManager::addToListAndMap (lCDGSFOSegmentYCabin,
                                    lCDGSFOSegmentYCabin1FamilyQClass);
    FacBomManager::addToListAndMap (lCDGSFOSegment,
                                    lCDGSFOSegmentYCabin1FamilyQClass);

    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lCDGSFOSegmentYCabin1FamilyQClass.toString());

    /*================================================================================
      ================================================================================
      ================================================================================*/
    // Schedule:
    // BA:
    // Step 1: flight period level
    // Create a flight period for BA9:
    const DoWStruct lDoWSrtuct ("1111111");
    const Date_T lBA9DateRangeStart (2010, boost::gregorian::Jun, 6);
    const Date_T lBA9DateRangeEnd (2010, boost::gregorian::Jun, 7);
    const DatePeriod_T lBA9DatePeriod (lBA9DateRangeStart, lBA9DateRangeEnd);
    const PeriodStruct lBA9PeriodStruct (lBA9DatePeriod, lDoWSrtuct);

    lFlightNumber = FlightNumber_T (9);

    FlightPeriodKey lBA9FlightPeriodKey (lFlightNumber, lBA9PeriodStruct);

    FlightPeriod& lBA9FlightPeriod =
      FacBom<FlightPeriod>::instance().create (lBA9FlightPeriodKey);
    FacBomManager::addToListAndMap (lBAInv, lBA9FlightPeriod);
    FacBomManager::linkWithParent (lBAInv, lBA9FlightPeriod);

    // Step 2: segment period level
    // Create a segment period for LHR-SYD:

    SegmentPeriodKey lLHRSYDSegmentPeriodKey (lLHR, lSYD);

    SegmentPeriod& lLHRSYDSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lLHRSYDSegmentPeriodKey);
    FacBomManager::addToListAndMap (lBA9FlightPeriod, lLHRSYDSegmentPeriod);
    FacBomManager::linkWithParent (lBA9FlightPeriod, lLHRSYDSegmentPeriod);

    lLHRSYDSegmentPeriod.setBoardingTime (l2135);
    lLHRSYDSegmentPeriod.setOffTime (l1540);
    lLHRSYDSegmentPeriod.setElapsedTime (l1105);
    ClassList_String_T lYM ("YM");
    lLHRSYDSegmentPeriod.addCabinBookingClassList (lY,lYM);

    // AF:
    // Step 1: flight period level
    // Create a flight period for AF84:
    const Date_T lAF84DateRangeStart (2011, boost::gregorian::Mar, 20);
    const Date_T lAF84DateRangeEnd (2011, boost::gregorian::Mar, 21);
    const DatePeriod_T lAF84DatePeriod (lAF84DateRangeStart, lAF84DateRangeEnd);
    const PeriodStruct lAF84PeriodStruct (lAF84DatePeriod, lDoWSrtuct);

    lFlightNumber = FlightNumber_T (84);

    FlightPeriodKey lAF84FlightPeriodKey (lFlightNumber, lAF84PeriodStruct);

    FlightPeriod& lAF84FlightPeriod =
      FacBom<FlightPeriod>::instance().create (lAF84FlightPeriodKey);
    FacBomManager::addToListAndMap (lAFInv, lAF84FlightPeriod);
    FacBomManager::linkWithParent (lAFInv, lAF84FlightPeriod);

    // Step 2: segment period level
    // Create a segment period for CDG-SFO:

    SegmentPeriodKey lCDGSFOSegmentPeriodKey (lCDG, lSFO);

    SegmentPeriod& lCDGSFOSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lCDGSFOSegmentPeriodKey);
    FacBomManager::addToListAndMap (lAF84FlightPeriod, lCDGSFOSegmentPeriod);
    FacBomManager::linkWithParent (lAF84FlightPeriod, lCDGSFOSegmentPeriod);

    lCDGSFOSegmentPeriod.setBoardingTime (l1040);
    lCDGSFOSegmentPeriod.setOffTime (l1250);
    lCDGSFOSegmentPeriod.setElapsedTime (l1110);
    lCDGSFOSegmentPeriod.addCabinBookingClassList (lY,lYM);

    /*================================================================================
      ================================================================================
      ================================================================================*/
    // O&D 
    // Create an O&D Date (BA;9,2010-Jun-06;LHR,SYD) for BA's Inventory
    OnDString_T  lBALHRSYDOnDStr = "BA;9,2010-Jun-06;LHR,SYD";
    OnDStringList_T lBAOnDStrList;
    lBAOnDStrList.push_back (lBALHRSYDOnDStr);

    OnDDateKey lBAOnDDateKey (lBAOnDStrList);
    OnDDate& lBA_LHRSYD_OnDDate =
      FacBom<OnDDate>::instance().create (lBAOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lBAInv, lBA_LHRSYD_OnDDate);
    FacBomManager::linkWithParent (lBAInv, lBA_LHRSYD_OnDDate);

    // Add the segment
    FacBomManager::addToListAndMap (lBA_LHRSYD_OnDDate, lLHRSYDSegment);

    // Add total forecast info for cabin Y.
    const MeanStdDevPair_T lMean60StdDev6 (60.0, 6.0);
    const WTP_T lWTP750 = 750.0;
    const WTPDemandPair_T lWTP750Mean60StdDev6 (lWTP750, lMean60StdDev6);
    lBA_LHRSYD_OnDDate.setTotalForecast (lY, lWTP750Mean60StdDev6);

    // Create an O&D Date (AF;84,2011-Mar-21;CDG,SFO) for AF's Inventory
    OnDString_T lAFLHRSYDOnDStr = "AF;9,2011-Mar-20;CDG,SFO";
    OnDStringList_T lAFOnDStrList;
    lAFOnDStrList.push_back (lAFLHRSYDOnDStr);

    OnDDateKey lAFOnDDateKey (lAFOnDStrList);
    OnDDate& lAF_LHRSYD_OnDDate =
      FacBom<OnDDate>::instance().create (lAFOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lAFInv, lAF_LHRSYD_OnDDate);
    FacBomManager::linkWithParent (lAFInv, lAF_LHRSYD_OnDDate);

    // Add the segment
    FacBomManager::addToListAndMap (lAF_LHRSYD_OnDDate, lLHRSYDSegment);

    // Add total forecast info for cabin Y. 
    lAF_LHRSYD_OnDDate.setTotalForecast (lY, lWTP750Mean60StdDev6);
    
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::
  buildSampleInventoryScheduleForFareFamilies (BomRoot& ioBomRoot) {

    // Inventory
    // Step 0.1: Inventory level
    // Get the Inventory SQ (already built by construction)  
    const InventoryKey lSQKey ("SQ");
    Inventory& lSQInv = BomManager::getObject<Inventory>(ioBomRoot,
                                                         lSQKey.toString());

    // SQ
    // Step 0.2: Flight-date level
    // Create a FlightDate (SQ747/8-FEB-2010) for SQ's Inventory
    const FlightNumber_T lFlightNumber747 = 747;
    const Date_T lDate (2010, 2, 8);
    const FlightDateKey lFlightDateKey (lFlightNumber747, lDate);

    FlightDate& lSQ747_20100208_FD =
        FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lSQInv, lSQ747_20100208_FD);
    FacBomManager::linkWithParent (lSQInv, lSQ747_20100208_FD);

    // Display the flight-date
    // STDAIR_LOG_DEBUG ("FlightDate: " << lSQ747_20100208_FD.toString());
    
    // Step 0.3: Segment-date level
    // Create a SegmentDate (SIN-BKK) for SQ's Inventory
    const AirportCode_T lSIN ("SIN");
    const AirportCode_T lBKK ("BKK");
    const Duration_T l0635 (6, 35, 0);
    const Duration_T l0800 (8, 0, 0);
    const Duration_T l0225 (2, 25, 0);
    const SegmentDateKey lSegmentDateKey (lSIN, lBKK);

    SegmentDate& lSINBKKSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lSQ747_20100208_FD, lSINBKKSegment);
    FacBomManager::linkWithParent (lSQ747_20100208_FD, lSINBKKSegment); 

    // Add the routing leg key to the SIN-BKK segment.
    const std::string lSQSINRoutingLegStr = "SQ;747;2010-Feb-8;SIN";
    lSINBKKSegment.addLegKey (lSQSINRoutingLegStr);

    // Fill the SegmentDate content
    lSINBKKSegment.setBoardingDate (lDate);
    lSINBKKSegment.setOffDate (lDate);
    lSINBKKSegment.setBoardingTime (l0635);
    lSINBKKSegment.setOffTime (l0800);
    lSINBKKSegment.setElapsedTime (l0225);
  
    // Display the segment-date
    // STDAIR_LOG_DEBUG ("SegmentDate: " << lSINBKKSegment);

    // Step 0.4: Leg-date level
    // Create a LegDate (SIN) for SQ's Inventory
    const LegDateKey lLegDateKey (lSIN);

    LegDate& lSINLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lSQ747_20100208_FD, lSINLeg);
    FacBomManager::linkWithParent (lSQ747_20100208_FD, lSINLeg);

    // Fill the LegDate content
    lSINLeg.setOffPoint (lBKK);
    lSINLeg.setBoardingDate (lDate);
    lSINLeg.setOffDate (lDate);
    lSINLeg.setBoardingTime (l0635);
    lSINLeg.setOffTime (l0800);
    lSINLeg.setElapsedTime (l0225);

    // Display the leg-date
    // STDAIR_LOG_DEBUG ("LegDate: " << lSINLeg.toString());

    // Step 0.5: segment-cabin level
    // Create a SegmentCabin (Y) for the Segment SIN-BKK of SQ's Inventory
    const CabinCode_T lY ("Y");
    const SegmentCabinKey lYSegmentCabinKey (lY);
    SegmentCabin& lSINBKKSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lSINBKKSegment, lSINBKKSegmentYCabin);
    FacBomManager::linkWithParent (lSINBKKSegment, lSINBKKSegmentYCabin);
    lSINBKKSegmentYCabin.activateFareFamily ();
    
    // Display the segment-cabin
    // STDAIR_LOG_DEBUG ("SegmentCabin: " << lSINBKKSegmentYCabin.toString());

    // Step 0.6: leg-cabin level
    // Create a LegCabin (Y) for the Leg SIN-BKK on SQ's Inventory
    const LegCabinKey lYLegCabinKey (lY);
    LegCabin& lSINLegYCabin =
      FacBom<LegCabin>::instance().create (lYLegCabinKey);
    FacBomManager::addToListAndMap (lSINLeg, lSINLegYCabin);
    FacBomManager::linkWithParent (lSINLeg, lSINLegYCabin);

    // Display the leg-cabin
    // STDAIR_LOG_DEBUG ("LegCabin: " << lSINLegYCabin.toString());
   
    // Step 0.7: fare family level
    // Create a FareFamily (1) for the Segment SIN-BKK, cabin Y on SQ's Inv
    const FamilyCode_T l1 ("1");
    const FareFamilyKey l1FareFamilyKey (l1);
    FareFamily& lSINBKKSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                      lSINBKKSegmentYCabin1Family);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin,
                                   lSINBKKSegmentYCabin1Family);
    
    // Display the booking class
    // STDAIR_LOG_DEBUG ("FareFamily: "
    //                   << lSINBKKSegmentYCabin1Family.toString());

    // Create a FareFamily (2) for the Segment SIN-BKK, cabin Y on SQ's Inv
    const FamilyCode_T l2 ("2");
    const FareFamilyKey l2FareFamilyKey (l2);
    FareFamily& lSINBKKSegmentYCabin2Family =
        FacBom<FareFamily>::instance().create (l2FareFamilyKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                      lSINBKKSegmentYCabin2Family);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin,
                                   lSINBKKSegmentYCabin2Family);
    
    // Display the booking class
    // STDAIR_LOG_DEBUG ("FareFamily: "
    //                   << lSINBKKSegmentYCabin2Family.toString());
   
    // Step 0.8: booking class level
    // Create a BookingClass (Y) for the Segment SIN-BKK, cabin Y,
    // fare family 2 on SQ's Inv
    const ClassCode_T lClassY ("Y");
    const BookingClassKey lYBookingClassKey (lClassY);
    BookingClass& lSINBKKSegmentYCabin2FamilyYClass =
      FacBom<BookingClass>::instance().create (lYBookingClassKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin2Family,
                                    lSINBKKSegmentYCabin2FamilyYClass);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin2Family,
                                   lSINBKKSegmentYCabin2FamilyYClass);

    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin2FamilyYClass);
    FacBomManager::addToListAndMap (lSINBKKSegment,
                                    lSINBKKSegmentYCabin2FamilyYClass);
    lSINBKKSegmentYCabin2FamilyYClass.setYield(1200);
    
    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lSINBKKSegmentYCabin2FamilyYClass.toString());
    
    // Create a BookingClass (B) for the Segment SIN-BKK, cabin Y,
    // fare family 2 on SQ's Inv
    const ClassCode_T lB ("B");
    const BookingClassKey lBBookingClassKey (lB);
    BookingClass& lSINBKKSegmentYCabin2FamilyBClass =
      FacBom<BookingClass>::instance().create (lBBookingClassKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin2Family,
                                    lSINBKKSegmentYCabin2FamilyBClass);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin2Family,
                                   lSINBKKSegmentYCabin2FamilyBClass);

    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin2FamilyBClass);
    FacBomManager::addToListAndMap (lSINBKKSegment,
                                    lSINBKKSegmentYCabin2FamilyBClass);
    lSINBKKSegmentYCabin2FamilyBClass.setYield(800);
    
    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lSINBKKSegmentYCabin2FamilyBClass.toString());

    // Create a BookingClass (M) for the Segment SIN-BKK, cabin Y,
    // fare family 1 on SQ's Inv
    const ClassCode_T lM ("M");
    const BookingClassKey lMBookingClassKey (lM);
    BookingClass& lSINBKKSegmentYCabin1FamilyMClass =
      FacBom<BookingClass>::instance().create (lMBookingClassKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin1Family,
                                    lSINBKKSegmentYCabin1FamilyMClass);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin1Family,
                                   lSINBKKSegmentYCabin1FamilyMClass);

    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin1FamilyMClass);
    FacBomManager::addToListAndMap (lSINBKKSegment,
                                    lSINBKKSegmentYCabin1FamilyMClass);
    lSINBKKSegmentYCabin1FamilyMClass.setYield(900);
    
    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lSINBKKSegmentYCabin1FamilyMClass.toString());
   
    // Create a BookingClass (Q) for the Segment SIN-BKK, cabin Y,
    // fare family 1 on SQ's Inv
    const ClassCode_T lQ ("Q");
    const BookingClassKey lQBookingClassKey (lQ);
    BookingClass& lSINBKKSegmentYCabin1FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin1Family,
                                    lSINBKKSegmentYCabin1FamilyQClass);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin1Family,
                                   lSINBKKSegmentYCabin1FamilyQClass);

    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin1FamilyQClass);
    FacBomManager::addToListAndMap (lSINBKKSegment,
                                    lSINBKKSegmentYCabin1FamilyQClass);
    lSINBKKSegmentYCabin1FamilyQClass.setYield(600);

  
    // Display the booking class
    // STDAIR_LOG_DEBUG ("BookingClass: "
    //                   << lSINBKKSegmentYCabin1FamilyQClass.toString());

    /*================================================================================
      ================================================================================
      ================================================================================*/
    // Schedule:
    // SQ:
    // Step 1: flight period level
    // Create a flight period for SQ747:
    const DoWStruct lDoWSrtuct ("1111111");
    const Date_T lSQ747DateRangeStart (2010, boost::gregorian::Feb, 8);
    const Date_T lSQ747DateRangeEnd (2010, boost::gregorian::Feb, 9);
    const DatePeriod_T lSQ747DatePeriod (lSQ747DateRangeStart, 
                                         lSQ747DateRangeEnd);
    const PeriodStruct lSQ747PeriodStruct (lSQ747DatePeriod, lDoWSrtuct);

    const FlightPeriodKey lSQ747FlightPeriodKey (lFlightNumber747, 
                                           lSQ747PeriodStruct);
    FlightPeriod& lSQ747FlightPeriod =
      FacBom<FlightPeriod>::instance().create (lSQ747FlightPeriodKey);
    FacBomManager::addToListAndMap (lSQInv, lSQ747FlightPeriod);
    FacBomManager::linkWithParent (lSQInv, lSQ747FlightPeriod);

    // Step 2: segment period level
    // Create a segment period for SIN-BKK:

    const SegmentPeriodKey lSINBKKSegmentPeriodKey (lSIN, lBKK);
    SegmentPeriod& lSINBKKSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lSINBKKSegmentPeriodKey);
    FacBomManager::addToListAndMap (lSQ747FlightPeriod, lSINBKKSegmentPeriod);
    FacBomManager::linkWithParent (lSQ747FlightPeriod, lSINBKKSegmentPeriod);
     
    ClassList_String_T lYBMQ  ("YBMQ");
    lSINBKKSegmentPeriod.addCabinBookingClassList (lY,lYBMQ);
    lSINBKKSegmentPeriod.setBoardingTime (l0635);
    lSINBKKSegmentPeriod.setOffTime (l0800);
    lSINBKKSegmentPeriod.setElapsedTime (l0225);

    /*================================================================================
      ================================================================================
      ================================================================================*/
    // O&D 
    // Create an O&D Date (SQ;747,2011-Feb-14;SIN,BKK) for SQ's Inventory
    const OnDString_T lSQSINBKKOnDStr = "SQ;747,2011-Feb-14;SIN,BKK";
    OnDStringList_T lSQOnDStrList;
    lSQOnDStrList.push_back (lSQSINBKKOnDStr);

    const OnDDateKey lSQOnDDateKey (lSQOnDStrList);
    OnDDate& lSQ_SINBKK_OnDDate =
      FacBom<OnDDate>::instance().create (lSQOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lSQInv, lSQ_SINBKK_OnDDate);
    FacBomManager::linkWithParent (lSQInv, lSQ_SINBKK_OnDDate);
    // Add total forecast info for cabin Y.
    const MeanStdDevPair_T lMean120StdDev12 (120.0, 12.0);
    const WTP_T lWTP1000 = 1000.0;
    const WTPDemandPair_T lWTP1000Mean120StdDev12 (lWTP1000, lMean120StdDev12);
    lSQ_SINBKK_OnDDate.setTotalForecast (lY, lWTP1000Mean120StdDev12);
 
    // Add the segment
    FacBomManager::addToListAndMap (lSQ_SINBKK_OnDDate, lSINBKKSegment);
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildDummyLegSegmentAccesses (BomRoot& ioBomRoot) {    

    /* Build the direct accesses between the dummy segment cabins and the dummy 
 leg cabins within the dummy flight dates (the dummy fare family 
 flight date and the classic dummy flight date).

 As for now (May 2012), that method is called only by RMOL.
 It is a substitute for the code doing it automatically located in AirInv.
 See the AIRINV::InventoryManager::createDirectAccesses command.
     */
   
    // ////// Dummy Inventory Leg Segment Accesses ///////
    // Retrieve the (sample) segment-cabin.
    SegmentCabin& lDummySegmentCabin =
      BomRetriever::retrieveDummySegmentCabin (ioBomRoot);
    
    // Retrieve the (sample) leg-cabin.
    LegCabin& lDummyLegCabin =
      BomRetriever::retrieveDummyLegCabin (ioBomRoot);

    // Links between the segment-date and the leg-date
    FacBomManager::addToListAndMap (lDummyLegCabin, lDummySegmentCabin);
    FacBomManager::addToListAndMap (lDummySegmentCabin, lDummyLegCabin);
 
    // ////// Fare Families Dummy Inventory Leg Segment Accesses ///////
    const bool isForFareFamilies = true;
    // Retrieve the (sample) segment-cabin for fare families.
    SegmentCabin& lFFDummySegmentCabin =
      BomRetriever::retrieveDummySegmentCabin (ioBomRoot, isForFareFamilies);
    
    // Retrieve the (sample) leg-cabin for fare families.
    stdair::LegCabin& lFFDummyLegCabin =
      stdair::BomRetriever::retrieveDummyLegCabin (ioBomRoot, 
                                                   isForFareFamilies);

    // Links between the segment-date and the leg-date for fare families.
    FacBomManager::addToListAndMap (lFFDummyLegCabin, lFFDummySegmentCabin);
    FacBomManager::addToListAndMap (lFFDummySegmentCabin, lFFDummyLegCabin);
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildCompleteDummyInventory  (BomRoot& ioBomRoot) {

    // Build a dummy inventory, containing a dummy flight-date with a
    // single segment-cabin and a single leg-cabin.
    const CabinCapacity_T lCapacity = DEFAULT_CABIN_CAPACITY;
    buildDummyInventory (ioBomRoot, lCapacity);

    // Retrieve the (sample) segment-cabin.
    SegmentCabin& lDummySegmentCabin =
      BomRetriever::retrieveDummySegmentCabin (ioBomRoot);
    
    // Retrieve the (sample) leg-cabin.
    LegCabin& lDummyLegCabin =
      BomRetriever::retrieveDummyLegCabin (ioBomRoot);

    // Add some booking classes to the dummy segment-cabin and some
    // virtual ones to the dummy leg-cabin.
    // First booking class yield and demand information.
    Yield_T lYield = 100;
    MeanValue_T lMean = 20;
    StdDevValue_T lStdDev= 9;
    BookingClassKey lBCKey (DEFAULT_CLASS_CODE);

    BookingClass& lDummyBookingClass =
      FacBom<BookingClass>::instance().create (lBCKey);
    lDummyBookingClass.setYield (lYield);
    lDummyBookingClass.setMean (lMean);
    lDummyBookingClass.setStdDev (lStdDev);
    // Add a booking class to the segment-cabin.
    FacBomManager::addToList (lDummySegmentCabin, lDummyBookingClass);
    BookingClassList_T lDummyBookingClassList;
    lDummyBookingClassList.push_back(&lDummyBookingClass);

    VirtualClassStruct lDummyVirtualClass (lDummyBookingClassList);
    lDummyVirtualClass.setYield (lYield);
    lDummyVirtualClass.setMean (lMean);
    lDummyVirtualClass.setStdDev (lStdDev);
    // Add the corresponding virtual class to the leg-cabin.
    lDummyLegCabin.addVirtualClass (lDummyVirtualClass);

    // Second booking class yield and demand information.
    lYield = 70;
    lMean = 45;
    lStdDev= 12;
    lDummyBookingClass.setYield (lYield);
    lDummyBookingClass.setMean (lMean);
    lDummyBookingClass.setStdDev (lStdDev);
    // Add a booking class to the segment-cabin.
    FacBomManager::addToList (lDummySegmentCabin, lDummyBookingClass);

    lDummyVirtualClass.setYield (lYield);
    lDummyVirtualClass.setMean (lMean);
    lDummyVirtualClass.setStdDev (lStdDev);
    // Add the corresponding virtual class to the leg-cabin.
    lDummyLegCabin.addVirtualClass (lDummyVirtualClass);
    
    // Third booking class yield and demand information.
    lYield = 42;
    lMean = 80;
    lStdDev= 16;
    lDummyBookingClass.setYield (lYield);
    lDummyBookingClass.setMean (lMean);
    lDummyBookingClass.setStdDev (lStdDev);
    // Add a booking class to the segment-cabin.
    FacBomManager::addToList (lDummySegmentCabin, lDummyBookingClass);

    lDummyVirtualClass.setYield (lYield);
    lDummyVirtualClass.setMean (lMean);
    lDummyVirtualClass.setStdDev (lStdDev);
    // Add the corresponding virtual class to the leg-cabin.
    lDummyLegCabin.addVirtualClass (lDummyVirtualClass);
    
  }
  
  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildDummyInventory (BomRoot& ioBomRoot,
                                           const CabinCapacity_T& iCapacity) {
    // Inventory
    const InventoryKey lInventoryKey (DEFAULT_AIRLINE_CODE);
    Inventory& lInv = FacBom<Inventory>::instance().create (lInventoryKey);
    FacBomManager::addToListAndMap (ioBomRoot, lInv);
    FacBomManager::linkWithParent (ioBomRoot, lInv);

    // Add the airline feature object to the dummy inventory
    const AirlineFeatureKey lAirlineFeatureKey (DEFAULT_AIRLINE_CODE);
    AirlineFeature& lAirlineFeature =
      FacBom<AirlineFeature>::instance().create (lAirlineFeatureKey);
    FacBomManager::setAirlineFeature (lInv, lAirlineFeature);
    FacBomManager::linkWithParent (lInv, lAirlineFeature);
    // Link the airline feature object with the top of the BOM tree
    FacBomManager::addToListAndMap (ioBomRoot, lAirlineFeature);

    // Flight-date
    FlightDateKey lFlightDateKey(DEFAULT_FLIGHT_NUMBER, DEFAULT_DEPARTURE_DATE);
    FlightDate& lFlightDate =
      FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lInv, lFlightDate);
    FacBomManager::linkWithParent (lInv, lFlightDate);

    // Leg-date
    LegDateKey lLegDateKey (DEFAULT_ORIGIN);
    LegDate& lLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lFlightDate, lLeg);
    FacBomManager::linkWithParent (lFlightDate, lLeg);

    // Fill the LegDate content
    lLeg.setOffPoint (DEFAULT_DESTINATION);
    lLeg.setBoardingDate (DEFAULT_DEPARTURE_DATE);
    lLeg.setOffDate (DEFAULT_DEPARTURE_DATE);
    lLeg.setBoardingTime (Duration_T (14, 0, 0));
    lLeg.setOffTime (Duration_T (16, 0, 0));
    lLeg.setElapsedTime (Duration_T (8, 0, 0));

    // Leg-cabin
    LegCabinKey lLegCabinKey (DEFAULT_CABIN_CODE);
    LegCabin& lLegCabin = FacBom<LegCabin>::instance().create (lLegCabinKey);
    FacBomManager::addToListAndMap (lLeg, lLegCabin);
    FacBomManager::linkWithParent (lLeg, lLegCabin);

    lLegCabin.setCapacities (iCapacity);
    lLegCabin.setAvailabilityPool (iCapacity);

    // Segment-date
    SegmentDateKey lSegmentDateKey (DEFAULT_ORIGIN, DEFAULT_DESTINATION);
    SegmentDate& lSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lFlightDate, lSegment);
    FacBomManager::linkWithParent (lFlightDate, lSegment); 

    // Add the routing leg key to the dummy segment.
    std::ostringstream oStr;
    oStr << DEFAULT_AIRLINE_CODE << ";"
         << DEFAULT_FLIGHT_NUMBER << ";" 
         << DEFAULT_DEPARTURE_DATE << ";"
         << DEFAULT_ORIGIN;
    lSegment.addLegKey (oStr.str());

    // Fill the SegmentDate content
    lSegment.setBoardingDate (DEFAULT_DEPARTURE_DATE);
    lSegment.setOffDate (DEFAULT_DEPARTURE_DATE);
    lSegment.setBoardingTime (Duration_T (14, 0, 0));
    lSegment.setOffTime (Duration_T (16, 0, 0));
    lSegment.setElapsedTime (Duration_T (8, 0, 0));

    // Segment-cabin
    SegmentCabinKey lSegmentCabinKey (DEFAULT_CABIN_CODE);
    SegmentCabin& lSegmentCabin =
      FacBom<SegmentCabin>::instance().create (lSegmentCabinKey);
    FacBomManager::addToListAndMap (lSegment, lSegmentCabin);
    FacBomManager::linkWithParent (lSegment, lSegmentCabin);

    // Create a FareFamily (1) for the Segment LHR-BKK, cabin Y on BA's Inv
    const FamilyCode_T l1 ("EcoSaver");
    FareFamilyKey l1FareFamilyKey (l1);

    FareFamily& lSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin1Family);
    FacBomManager::linkWithParent (lSegmentCabin, lSegmentYCabin1Family);

    // Create a booking-class
    const ClassCode_T lQ ("Q");
    BookingClassKey lQBookingClassKey (lQ);

    BookingClass& lSegmentYCabin1FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    FacBomManager::addToListAndMap (lSegmentYCabin1Family,
                                    lSegmentYCabin1FamilyQClass);
    FacBomManager::linkWithParent (lSegmentYCabin1Family,
                                   lSegmentYCabin1FamilyQClass);
    
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin1FamilyQClass);
    FacBomManager::addToListAndMap (lSegment, lSegmentYCabin1FamilyQClass);

    /*================================================================================
      ================================================================================
      ================================================================================*/
    // Schedule:
    // XX:
    // Step 1: flight period level
    // Create a flight period for XX:
    const DoWStruct lDoWSrtuct ("1111111");
    const Date_T lXXDateRangeStart (DEFAULT_DEPARTURE_DATE);
    const Date_T lXXDateRangeEnd (DEFAULT_DEPARTURE_DATE);
    const DatePeriod_T lXXDatePeriod (lXXDateRangeStart, lXXDateRangeEnd);
    const PeriodStruct lXXPeriodStruct (lXXDatePeriod, lDoWSrtuct);

    FlightPeriodKey lXXFlightPeriodKey (DEFAULT_FLIGHT_NUMBER, lXXPeriodStruct);

    FlightPeriod& lXXFlightPeriod =
      FacBom<FlightPeriod>::instance().create (lXXFlightPeriodKey);
    FacBomManager::addToListAndMap (lInv, lXXFlightPeriod);
    FacBomManager::linkWithParent (lInv, lXXFlightPeriod);

    // Step 2: segment period level
    // Create a segment period 

    SegmentPeriodKey lXXSegmentPeriodKey (DEFAULT_ORIGIN, DEFAULT_DESTINATION);

    SegmentPeriod& lXXSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lXXSegmentPeriodKey);
    FacBomManager::addToListAndMap (lXXFlightPeriod, lXXSegmentPeriod);
    FacBomManager::linkWithParent (lXXFlightPeriod, lXXSegmentPeriod);

    lXXSegmentPeriod.setBoardingTime (Duration_T (14, 0, 0));
    lXXSegmentPeriod.setOffTime (Duration_T (16, 0, 0));
    lXXSegmentPeriod.setElapsedTime (Duration_T (8, 0, 0));
    const CabinCode_T lY ("Y");
    const ClassList_String_T lYQ ("YQ");
    lXXSegmentPeriod.addCabinBookingClassList (lY,lYQ);


  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::
  buildCompleteDummyInventoryForFareFamilies (BomRoot& ioBomRoot) {

    // Build a dummy inventory, containing a dummy flight-date with a
    // single segment-cabin and a single leg-cabin (for fare families 
    // algorithms)

    // Get the default Inventory object (already built in by construction)
    const InventoryKey lInventoryKey (DEFAULT_AIRLINE_CODE);
    Inventory& lInv = BomManager::getObject<Inventory>(ioBomRoot,
                                                  lInventoryKey.toString());

    // Create a dummy Flight-date
    const FlightDateKey lFlightDateKey(DEFAULT_FLIGHT_NUMBER_FF, 
                                       DEFAULT_DEPARTURE_DATE);
    FlightDate& lFlightDate = 
      FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lInv, lFlightDate);
    FacBomManager::linkWithParent (lInv, lFlightDate);

    // Create a dummy Leg-date
    LegDateKey lLegDateKey (DEFAULT_ORIGIN);
    LegDate& lLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lFlightDate, lLeg);
    FacBomManager::linkWithParent (lFlightDate, lLeg);

    // Fill the LegDate content
    lLeg.setOffPoint (DEFAULT_DESTINATION);
    lLeg.setBoardingDate (DEFAULT_DEPARTURE_DATE);
    lLeg.setOffDate (DEFAULT_DEPARTURE_DATE);
    lLeg.setBoardingTime (Duration_T (14, 0, 0));
    lLeg.setOffTime (Duration_T (16, 0, 0));
    lLeg.setElapsedTime (Duration_T (8, 0, 0));

    // Create a dummy Leg-cabin
    const LegCabinKey lLegCabinKey (DEFAULT_CABIN_CODE);
    LegCabin& lLegCabin = FacBom<LegCabin>::instance().create (lLegCabinKey);
    FacBomManager::addToListAndMap (lLeg, lLegCabin);
    FacBomManager::linkWithParent (lLeg, lLegCabin);
    const CabinCapacity_T lCapacity = DEFAULT_CABIN_CAPACITY;
    lLegCabin.setCapacities (lCapacity);
    lLegCabin.setAvailabilityPool (lCapacity);

    // Create a dummy Segment-date
    const SegmentDateKey lSegmentDateKey (DEFAULT_ORIGIN, DEFAULT_DESTINATION);
    SegmentDate& lSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lFlightDate, lSegment);
    FacBomManager::linkWithParent (lFlightDate, lSegment); 

    // Add the routing leg key to the dummy segment.
    std::ostringstream oStr;
    oStr << DEFAULT_AIRLINE_CODE << ";"
         << DEFAULT_FLIGHT_NUMBER << ";" 
         << DEFAULT_DEPARTURE_DATE << ";"
         << DEFAULT_ORIGIN;
    lSegment.addLegKey (oStr.str());

    // Fill the SegmentDate content
    lSegment.setBoardingDate (DEFAULT_DEPARTURE_DATE);
    lSegment.setOffDate (DEFAULT_DEPARTURE_DATE);
    lSegment.setBoardingTime (Duration_T (14, 0, 0));
    lSegment.setOffTime (Duration_T (16, 0, 0));
    lSegment.setElapsedTime (Duration_T (8, 0, 0));

    // Create a dummy Segment-cabin
    const SegmentCabinKey lSegmentCabinKey (DEFAULT_CABIN_CODE);
    SegmentCabin& lSegmentCabin =
      FacBom<SegmentCabin>::instance().create (lSegmentCabinKey);
    FacBomManager::addToListAndMap (lSegment, lSegmentCabin);
    FacBomManager::linkWithParent (lSegment, lSegmentCabin);

    // Create a dummy FareFamily (FF1) 
    const FamilyCode_T l1 ("FF1");
    const FareFamilyKey l1FareFamilyKey (l1);

    FareFamily& lSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    // Set the forecasted demand
    // TODO change the size (hard code)
    MeanStdDevPairVector_T lDemandVector1FareFamily;
    const unsigned int size = 16;
    for (unsigned int idx = 0; idx < size; ++idx) {
      double i = static_cast<double> (idx);
      MeanStdDevPair_T lMeanStdDevPair (i/4.0, i/20.0);
      lDemandVector1FareFamily.push_back(lMeanStdDevPair);
    }
    lSegmentYCabin1Family.setMeanStdDev(lDemandVector1FareFamily);
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin1Family);
    FacBomManager::linkWithParent (lSegmentCabin, lSegmentYCabin1Family);

    // Create a dummy booking-class
    const ClassCode_T lY ("Y");
    const BookingClassKey lYBookingClassKey (lY);

    BookingClass& lSegmentYCabin1FamilyYClass =
      FacBom<BookingClass>::instance().create (lYBookingClassKey);
    Yield_T lYield = 1000;
    lSegmentYCabin1FamilyYClass.setYield(lYield);
    FacBomManager::addToListAndMap (lSegmentYCabin1Family,
                                    lSegmentYCabin1FamilyYClass);
    FacBomManager::linkWithParent (lSegmentYCabin1Family,
                                   lSegmentYCabin1FamilyYClass);
    
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin1FamilyYClass);
    FacBomManager::addToListAndMap (lSegment, lSegmentYCabin1FamilyYClass);

    // Create a second dummy booking-class
    const ClassCode_T lU ("U");
    const BookingClassKey lUBookingClassKey (lU);

    BookingClass& lSegmentYCabin1FamilyUClass =
      FacBom<BookingClass>::instance().create (lUBookingClassKey);
    lYield = 600;
    lSegmentYCabin1FamilyUClass.setYield(lYield);
    FacBomManager::addToListAndMap (lSegmentYCabin1Family,
                                    lSegmentYCabin1FamilyUClass);
    FacBomManager::linkWithParent (lSegmentYCabin1Family,
                                   lSegmentYCabin1FamilyUClass);
    
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin1FamilyUClass);
    FacBomManager::addToListAndMap (lSegment, lSegmentYCabin1FamilyUClass);

    // Create a second dummy FareFamily (2) 
    const FamilyCode_T l2 ("FF2");
    const FareFamilyKey l2FareFamilyKey (l2);

    FareFamily& lSegmentYCabin2Family =
      FacBom<FareFamily>::instance().create (l2FareFamilyKey);
    // Set the forecasted demand
    // TODO change the size (hard code)
    MeanStdDevPairVector_T lDemandVector2FareFamily;
    for (unsigned int idx = 0; idx < size; ++idx) {
      double i = static_cast<double> (idx);
      MeanStdDevPair_T lMeanStdDevPair (i/2.0, i/10.0);
      lDemandVector2FareFamily.push_back(lMeanStdDevPair);
    }
    lSegmentYCabin2Family.setMeanStdDev(lDemandVector2FareFamily);

    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin2Family);
    FacBomManager::linkWithParent (lSegmentCabin, lSegmentYCabin2Family);

    // Create a third dummy booking-class
    const ClassCode_T lO ("O");
    const BookingClassKey lOBookingClassKey (lO);

    BookingClass& lSegmentYCabin2FamilyOClass =
      FacBom<BookingClass>::instance().create (lOBookingClassKey);
    lYield = 750;
    lSegmentYCabin2FamilyOClass.setYield(lYield);
    FacBomManager::addToListAndMap (lSegmentYCabin2Family,
                                    lSegmentYCabin2FamilyOClass);
    FacBomManager::linkWithParent (lSegmentYCabin2Family,
                                   lSegmentYCabin2FamilyOClass);
    
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin2FamilyOClass);
    FacBomManager::addToListAndMap (lSegment, lSegmentYCabin2FamilyOClass);

     // Create a fourth dummy booking-class
    const ClassCode_T lQ ("Q");
    const BookingClassKey lQBookingClassKey (lQ);

    BookingClass& lSegmentYCabin2FamilyQClass =
      FacBom<BookingClass>::instance().create (lQBookingClassKey);
    lYield = 400;
    lSegmentYCabin2FamilyQClass.setYield(lYield);
    FacBomManager::addToListAndMap (lSegmentYCabin2Family,
                                    lSegmentYCabin2FamilyQClass);
    FacBomManager::linkWithParent (lSegmentYCabin2Family,
                                   lSegmentYCabin2FamilyQClass);
    
    FacBomManager::addToListAndMap (lSegmentCabin, lSegmentYCabin2FamilyQClass);
    FacBomManager::addToListAndMap (lSegment, lSegmentYCabin2FamilyQClass);


    /*================================================================================
      ================================================================================
      ================================================================================*/
    // Schedule:
    // XX:
    // Step 1: flight period level
    // Create a flight period for XX:
    const DoWStruct lDoWSrtuct ("1111111");
    const Date_T lXXDateRangeStart (DEFAULT_DEPARTURE_DATE);
    const Date_T lXXDateRangeEnd (DEFAULT_DEPARTURE_DATE);
    const DatePeriod_T lXXDatePeriod (lXXDateRangeStart, lXXDateRangeEnd);
    const PeriodStruct lXXPeriodStruct (lXXDatePeriod, lDoWSrtuct);

    const FlightPeriodKey lXXFlightPeriodKey (DEFAULT_FLIGHT_NUMBER_FF, 
                                              lXXPeriodStruct);

    FlightPeriod& lXXFlightPeriod =
      FacBom<FlightPeriod>::instance().create (lXXFlightPeriodKey);
    FacBomManager::addToListAndMap (lInv, lXXFlightPeriod);
    FacBomManager::linkWithParent (lInv, lXXFlightPeriod);

    // Step 2: segment period level
    // Create a segment period 
    const SegmentPeriodKey lXXSegmentPeriodKey (DEFAULT_ORIGIN, 
                                                DEFAULT_DESTINATION);

    SegmentPeriod& lXXSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lXXSegmentPeriodKey);
    FacBomManager::addToListAndMap (lXXFlightPeriod, lXXSegmentPeriod);
    FacBomManager::linkWithParent (lXXFlightPeriod, lXXSegmentPeriod);

    lXXSegmentPeriod.setBoardingTime (Duration_T (14, 0, 0));
    lXXSegmentPeriod.setOffTime (Duration_T (16, 0, 0));
    lXXSegmentPeriod.setElapsedTime (Duration_T (8, 0, 0));
    const CabinCode_T lYCabin ("Y");
    const ClassList_String_T lYUOQ ("YUOQ");
    lXXSegmentPeriod.addCabinBookingClassList (lYCabin,lYUOQ);

  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildSamplePricing (BomRoot& ioBomRoot) {

    // Set the airport-pair primary key.
    const AirportPairKey lAirportPairKey (AIRPORT_LHR, AIRPORT_SYD);
    
    // Create the AirportPairKey object and link it to the BOM tree root.
    AirportPair& lAirportPair =
      FacBom<AirportPair>::instance().create (lAirportPairKey);
    FacBomManager::addToListAndMap (ioBomRoot, lAirportPair);
    FacBomManager::linkWithParent (ioBomRoot, lAirportPair);

    // Set the fare date-period primary key.
    const Date_T lDateRangeStart (2011, boost::gregorian::Jan, 15);
    const Date_T lDateRangeEnd (2011, boost::gregorian::Dec, 31);
    const DatePeriod_T lDateRange (lDateRangeStart, lDateRangeEnd);
    const DatePeriodKey lDatePeriodKey (lDateRange);

    // Create the DatePeriodKey object and link it to the PosChannel object.
    DatePeriod& lDatePeriod =
      FacBom<DatePeriod>::instance().create (lDatePeriodKey);
    FacBomManager::addToListAndMap (lAirportPair, lDatePeriod);
    FacBomManager::linkWithParent (lAirportPair, lDatePeriod);    

    // Set the point-of-sale-channel primary key.
    const PosChannelKey lPosChannelKey (POS_LHR, CHANNEL_DN);  
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lDatePeriod, lPosChannel);
    FacBomManager::linkWithParent (lDatePeriod, lPosChannel);
   
    // Set the fare time-period primary key.
    const Time_T lTimeRangeStart (0, 0, 0);
    const Time_T lTimeRangeEnd (23, 0, 0);
    const TimePeriodKey lTimePeriodKey (lTimeRangeStart, lTimeRangeEnd);

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lTimePeriod =
      FacBom<TimePeriod>::instance().create (lTimePeriodKey);
    FacBomManager::addToListAndMap (lPosChannel, lTimePeriod);
    FacBomManager::linkWithParent (lPosChannel, lTimePeriod);        

    // Pricing -- Generate the FareRule
    const FareFeaturesKey lFareFeaturesKey (TRIP_TYPE_ROUND_TRIP,
                                            NO_ADVANCE_PURCHASE,
                                            SATURDAY_STAY,
                                            CHANGE_FEES,
                                            NON_REFUNDABLE,
                                            NO_STAY_DURATION);

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lFareFeatures =
      FacBom<FareFeatures>::instance().create (lFareFeaturesKey);
    FacBomManager::addToListAndMap (lTimePeriod, lFareFeatures);
    FacBomManager::linkWithParent (lTimePeriod, lFareFeatures);        

    // Revenue Accounting -- Generate the YieldRule
    const YieldFeaturesKey lYieldFeaturesKey (TRIP_TYPE_ROUND_TRIP,
                                              CABIN_Y);
    
    // Create the YieldFeaturesKey and link it to the TimePeriod object.
    YieldFeatures& lYieldFeatures =
      FacBom<YieldFeatures>::instance().create (lYieldFeaturesKey);
    FacBomManager::addToListAndMap (lTimePeriod, lYieldFeatures);
    FacBomManager::linkWithParent (lTimePeriod, lYieldFeatures);     
                                              
    // Generate Segment Features and link them to their respective
    // fare and yield rules.
    AirlineCodeList_T lAirlineCodeList;
    lAirlineCodeList.push_back (AIRLINE_CODE_BA);
    ClassList_StringList_T lClassCodeList;
    lClassCodeList.push_back (CLASS_CODE_Y);
    const AirlineClassListKey lAirlineClassListKey (lAirlineCodeList,
                                                    lClassCodeList);

    // Create the AirlineClassList
    AirlineClassList& lAirlineClassList =
      FacBom<AirlineClassList>::instance().create (lAirlineClassListKey);
    // Link the AirlineClassList to the FareFeatures object
    lAirlineClassList.setFare (900);
    FacBomManager::addToListAndMap (lFareFeatures, lAirlineClassList);
    FacBomManager::linkWithParent (lFareFeatures, lAirlineClassList);

    // Link the AirlineClassList to the YieldFeatures object
    lAirlineClassList.setYield (900);
    FacBomManager::addToListAndMap (lYieldFeatures, lAirlineClassList);
    // \todo (gsabatier): the following calls overrides the parent for
    //       lAirlineClassList. Check that it is what is actually wanted.
    FacBomManager::linkWithParent (lYieldFeatures, lAirlineClassList);
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildSamplePricingForFareFamilies (BomRoot& ioBomRoot) {

    // Get the airport-pair primary key SIN-BKK
    // (already built by construction)
    const AirportPairKey lAirportPairKey ("SIN", "BKK");
    AirportPair& lAirportPair =
      BomManager::getObject<AirportPair>(ioBomRoot, lAirportPairKey.toString());

    // Set the fare date-period primary key.
    const Date_T lDateRangeStart (2010, boost::gregorian::Feb, 1);
    const Date_T lDateRangeEnd (2011, boost::gregorian::Feb, 15);
    const DatePeriod_T lDateRange (lDateRangeStart, lDateRangeEnd);
    const DatePeriodKey lDatePeriodKey (lDateRange);

    // Create the DatePeriodKey object and link it to the PosChannel object.
    DatePeriod& lDatePeriod =
      FacBom<DatePeriod>::instance().create (lDatePeriodKey);
    FacBomManager::addToListAndMap (lAirportPair, lDatePeriod);
    FacBomManager::linkWithParent (lAirportPair, lDatePeriod);  

    // Set the point-of-sale-channel primary key.
    const PosChannelKey lPosChannelKey ("SIN", CHANNEL_IN);  
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lDatePeriod, lPosChannel);
    FacBomManager::linkWithParent (lDatePeriod, lPosChannel);

    // Set the fare time-period primary key.
    const Time_T lTimeRangeStart (0, 0, 0);
    const Time_T lTimeRangeEnd (23, 0, 0);
    const TimePeriodKey lTimePeriodKey (lTimeRangeStart, lTimeRangeEnd);

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lTimePeriod =
      FacBom<TimePeriod>::instance().create (lTimePeriodKey);
    FacBomManager::addToListAndMap (lPosChannel, lTimePeriod);
    FacBomManager::linkWithParent (lPosChannel, lTimePeriod);        

    // Pricing -- Generate the FareRule
    const DayDuration_T ONE_MONTH_ADVANCE_PURCHASE = 30;
    // Generate the first FareFeatures for the class Q 
    const FareFeaturesKey lFareFeaturesQKey (TRIP_TYPE_ONE_WAY,
                                            ONE_MONTH_ADVANCE_PURCHASE,
                                            SATURDAY_STAY,
                                            CHANGE_FEES,
                                            NON_REFUNDABLE,
                                            NO_STAY_DURATION);

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lFareFeaturesQ =
      FacBom<FareFeatures>::instance().create (lFareFeaturesQKey);
    FacBomManager::addToListAndMap (lTimePeriod, lFareFeaturesQ);
    FacBomManager::linkWithParent (lTimePeriod, lFareFeaturesQ);

    // Generate the second FareFeatures for the class M 
    const FareFeaturesKey lFareFeaturesMKey (TRIP_TYPE_ONE_WAY,
                                            NO_ADVANCE_PURCHASE,
                                            SATURDAY_STAY,
                                            CHANGE_FEES,
                                            NON_REFUNDABLE,
                                            NO_STAY_DURATION);

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lFareFeaturesM =
      FacBom<FareFeatures>::instance().create (lFareFeaturesMKey);
    FacBomManager::addToListAndMap (lTimePeriod, lFareFeaturesM);
    FacBomManager::linkWithParent (lTimePeriod, lFareFeaturesM); 

    // Generate the third FareFeatures for the class B
    const FareFeaturesKey lFareFeaturesBKey (TRIP_TYPE_ONE_WAY,
                                             ONE_MONTH_ADVANCE_PURCHASE,
                                             SATURDAY_STAY,
                                             NO_CHANGE_FEES,
                                             NO_NON_REFUNDABLE,//Refundable
                                             NO_STAY_DURATION);

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lFareFeaturesB =
      FacBom<FareFeatures>::instance().create (lFareFeaturesBKey);
    FacBomManager::addToListAndMap (lTimePeriod, lFareFeaturesB);
    FacBomManager::linkWithParent (lTimePeriod, lFareFeaturesB);       

    // Generate the fourth FareFeatures for the class Y
    const FareFeaturesKey lFareFeaturesYKey (TRIP_TYPE_ONE_WAY,
                                            NO_ADVANCE_PURCHASE,
                                            SATURDAY_STAY,
                                            NO_CHANGE_FEES,
                                            NO_NON_REFUNDABLE,//Refundable
                                            NO_STAY_DURATION);

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lFareFeaturesY =
      FacBom<FareFeatures>::instance().create (lFareFeaturesYKey);
    FacBomManager::addToListAndMap (lTimePeriod, lFareFeaturesY);
    FacBomManager::linkWithParent (lTimePeriod, lFareFeaturesY);
  
    // Revenue Accounting -- Generate the YieldRule
    const YieldFeaturesKey lYieldFeaturesKey (TRIP_TYPE_ONE_WAY,
                                              CABIN_Y);

    // Create the YieldFeaturesKey and link it to the TimePeriod object.
    YieldFeatures& lYieldFeatures =
      FacBom<YieldFeatures>::instance().create (lYieldFeaturesKey);
    FacBomManager::addToListAndMap (lTimePeriod, lYieldFeatures);
    FacBomManager::linkWithParent (lTimePeriod, lYieldFeatures);
                                  
    // Generate Segment Features and link them to their respective
    // fare and yield rules.
    AirlineCodeList_T lAirlineCodeList;
    lAirlineCodeList.push_back ("SQ");

    ClassList_StringList_T lClassYList;
    lClassYList.push_back (CLASS_CODE_Y);
    const AirlineClassListKey lAirlineClassYListKey (lAirlineCodeList,
                                                    lClassYList);
    
    // Create the AirlineClassList
    AirlineClassList& lAirlineClassYList =
        FacBom<AirlineClassList>::instance().create (lAirlineClassYListKey);
    // Link the AirlineClassList to the FareFeatures object
    FacBomManager::addToListAndMap (lFareFeaturesY, lAirlineClassYList);
    FacBomManager::linkWithParent (lFareFeaturesY, lAirlineClassYList);
    lAirlineClassYList.setFare (1200);    
    lAirlineClassYList.setYield (1200);

    // Link the AirlineClassList to the YieldFeatures object
    FacBomManager::addToListAndMap (lYieldFeatures, lAirlineClassYList);
    // \todo (gsabatier): the following calls overrides the parent for
    //       lAirlineClassList. Check that it is what is actually wanted.
    FacBomManager::linkWithParent (lYieldFeatures, lAirlineClassYList);

    ClassList_StringList_T lClassBList;
    lClassBList.push_back ("B");
    const AirlineClassListKey lAirlineClassBListKey (lAirlineCodeList,
                                                     lClassBList);
    // Create the AirlineClassList
    AirlineClassList& lAirlineClassBList =
      FacBom<AirlineClassList>::instance().create (lAirlineClassBListKey);
    // Link the AirlineClassList to the FareFeatures object
    FacBomManager::addToListAndMap (lFareFeaturesB, lAirlineClassBList);
    FacBomManager::linkWithParent (lFareFeaturesB, lAirlineClassBList);
    lAirlineClassBList.setFare (800); 
    lAirlineClassBList.setYield (800);
  
    // Link the AirlineClassList to the YieldFeatures object
    FacBomManager::addToListAndMap (lYieldFeatures, lAirlineClassBList);
    // \todo (gsabatier): the following calls overrides the parent for
    //       lAirlineClassList. Check that it is what is actually wanted.
    FacBomManager::linkWithParent (lYieldFeatures, lAirlineClassBList);

    ClassList_StringList_T lClassMList;
    lClassMList.push_back ("M");
    const AirlineClassListKey lAirlineClassMListKey (lAirlineCodeList,
                                                    lClassMList);

    // Create the AirlineClassList
    AirlineClassList& lAirlineClassMList =
      FacBom<AirlineClassList>::instance().create (lAirlineClassMListKey);
    // Link the AirlineClassList to the FareFeatures object
    FacBomManager::addToListAndMap (lFareFeaturesM, lAirlineClassMList);
    FacBomManager::linkWithParent (lFareFeaturesM, lAirlineClassMList);
    lAirlineClassMList.setFare (900);   
    lAirlineClassMList.setYield (900);

    // Link the AirlineClassList to the YieldFeatures object
    FacBomManager::addToListAndMap (lYieldFeatures, lAirlineClassMList);
    // \todo (gsabatier): the following calls overrides the parent for
    //       lAirlineClassList. Check that it is what is actually wanted.
    FacBomManager::linkWithParent (lYieldFeatures, lAirlineClassMList);

    ClassList_StringList_T lClassQList;
    lClassQList.push_back ("Q");
    const AirlineClassListKey lAirlineClassQListKey (lAirlineCodeList,
                                                     lClassQList);

    // Create the AirlineClassList
    AirlineClassList& lAirlineClassQList =
      FacBom<AirlineClassList>::instance().create (lAirlineClassQListKey);
    // Link the AirlineClassList to the FareFeatures object
    FacBomManager::addToListAndMap (lFareFeaturesQ, lAirlineClassQList);
    FacBomManager::linkWithParent (lFareFeaturesQ, lAirlineClassQList);
    lAirlineClassQList.setFare (600);  
    lAirlineClassQList.setYield (600);
    
    // Link the AirlineClassList to the YieldFeatures object
    FacBomManager::addToListAndMap (lYieldFeatures, lAirlineClassQList);
    // \todo (gsabatier): the following calls overrides the parent for
    //       lAirlineClassList. Check that it is what is actually wanted.
    FacBomManager::linkWithParent (lYieldFeatures, lAirlineClassQList);
        
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::
  buildSampleTravelSolutionForPricing (TravelSolutionList_T& ioTravelSolutionList) {

    // Clean the list
    ioTravelSolutionList.clear();

    //
    const std::string lBA9_SegmentDateKey ("BA, 9, 2011-06-10, LHR, SYD, 21:45");

    // Add the segment date key to the travel solution
    TravelSolutionStruct lTS;
    lTS.addSegment (lBA9_SegmentDateKey);

    // Add the travel solution to the list
    ioTravelSolutionList.push_back (lTS);
  }
  
  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::
  buildSampleTravelSolutions (TravelSolutionList_T& ioTravelSolutionList) {

    // Clean the list
    ioTravelSolutionList.clear();

    //
    const std::string lBA9_SegmentDateKey ("BA, 9, 2011-06-10, LHR, SYD, 21:45");

    // Add the segment date key to the travel solution
    TravelSolutionStruct lTS1;
    lTS1.addSegment (lBA9_SegmentDateKey);

    // Fare option number 1
    const ClassCode_T lClassPathQ (CLASS_CODE_Q);
    const Fare_T lFare900 (900);
    const ChangeFees_T lChangeFee (CHANGE_FEES);
    const NonRefundable_T isNonRefundable (NON_REFUNDABLE);
    const SaturdayStay_T lSaturdayStay (SATURDAY_STAY);
    const FareOptionStruct lFareOption1 (lClassPathQ, lFare900, lChangeFee,
                                        isNonRefundable, lSaturdayStay);

    // Add (a copy of) the fare option
    lTS1.addFareOption (lFareOption1);
    //

    // Map of class availabilities: set the availability for the Q
    // booking class (the one corresponding to the fare option) to 8.
    ClassAvailabilityMap_T lClassAvailabilityMap1;
    const Availability_T lAvl1 (8);
    bool hasInsertOfQBeenSuccessful = lClassAvailabilityMap1.
      insert (ClassAvailabilityMap_T::value_type (lClassPathQ, lAvl1)).second;
    assert (hasInsertOfQBeenSuccessful == true);
    // Add the map to the dedicated list held by the travel solution
    lTS1.addClassAvailabilityMap (lClassAvailabilityMap1);

    // Add the travel solution to the list
    ioTravelSolutionList.push_back (lTS1);

    //
    const std::string lQF12_SegmentDateKey ("QF, 12, 2011-06-10, LHR, SYD, 20:45");

    // Add the segment date key to the travel solution
    TravelSolutionStruct lTS2;
    lTS2.addSegment (lQF12_SegmentDateKey);

    // Fare option number 2
    const ClassCode_T lClassPathY (CLASS_CODE_Y);
    const Fare_T lFare1000 (1000);
    const ChangeFees_T lNoChangeFee (NO_CHANGE_FEES);
    const NonRefundable_T isRefundable (NO_NON_REFUNDABLE);
    const FareOptionStruct lFareOption2 (lClassPathY, lFare1000, lNoChangeFee,
                                         isRefundable, lSaturdayStay);

    // Map of class availabilities: set the availability for the Y
    // booking class (the one corresponding to the fare option) to 9.
    ClassAvailabilityMap_T lClassAvailabilityMap2;
    const Availability_T lAvl2 (9);
    const bool hasInsertOfYBeenSuccessful = lClassAvailabilityMap2.
      insert (ClassAvailabilityMap_T::value_type (lClassPathY, lAvl2)).second;
    assert (hasInsertOfYBeenSuccessful == true);
    // Add the map to the dedicated list held by the travel solution
    lTS2.addClassAvailabilityMap (lClassAvailabilityMap2);

    // Add (a copy of) the fare option
    lTS2.addFareOption (lFareOption2);

    // Fare option number 3
    const Fare_T lFare920 (920);
    const FareOptionStruct lFareOption3 (lClassPathQ, lFare920, lNoChangeFee,
                                         isNonRefundable, lSaturdayStay);

    // Map of class availabilities: set the availability for the Q
    // booking class (the one corresponding to the fare option) to 9.
    hasInsertOfQBeenSuccessful = lClassAvailabilityMap2.
      insert (ClassAvailabilityMap_T::value_type (lClassPathQ, lAvl2)).second;
    assert (hasInsertOfYBeenSuccessful == true);
    // Add the map to the dedicated list held by the travel solution
    lTS2.addClassAvailabilityMap (lClassAvailabilityMap2);

    // Add (a copy of) the fare option
    lTS2.addFareOption (lFareOption3);

    // Add the travel solution to the list
    ioTravelSolutionList.push_back (lTS2);
    
  }

  // //////////////////////////////////////////////////////////////////////
  BookingRequestStruct CmdBomManager::buildSampleBookingRequest() {
    // Origin
    const AirportCode_T lOrigin (AIRPORT_LHR);

    // Destination
    const AirportCode_T lDestination (AIRPORT_SYD);

    // Point of Sale (POS)
    const CityCode_T lPOS (POS_LHR);

    // Preferred departure date (10-JUN-2011)
    const Date_T lPreferredDepartureDate (2011, boost::gregorian::Jun, 10);

    // Preferred departure time (08:00)
    const Duration_T lPreferredDepartureTime (8, 0, 0);

    // Date of the request (15-MAY-2011)
    const Date_T lRequestDate (2011, boost::gregorian::May, 15);

    // Time of the request (10:00)
    const Duration_T lRequestTime (10, 0, 0);

    // Date-time of the request (made of the date and time above)
    const DateTime_T lRequestDateTime (lRequestDate, lRequestTime);

    // Preferred cabin (also named class of service sometimes)
    const CabinCode_T lPreferredCabin (CABIN_ECO);

    // Number of persons in the party
    const PartySize_T lPartySize (3);

    // Channel (direct/indirect, on-line/off-line)
    const ChannelLabel_T lChannel (CHANNEL_DN);

    // Type of the trip (one-way, inbound/outbound of a return trip)
    const TripType_T lTripType (TRIP_TYPE_INBOUND);

    // Duration of the stay (expressed as a number of days)
    const DayDuration_T lStayDuration (DEFAULT_STAY_DURATION);

    // Frequent flyer tier (member, silver, gold, platinum, senator, etc)
    const FrequentFlyer_T lFrequentFlyerType (FREQUENT_FLYER_MEMBER);

    // Maximum willing-to-pay (WTP, expressed in monetary unit, e.g., EUR)
    const WTP_T lWTP (DEFAULT_WTP);

    // Value of time, for the customer (expressed in monetary unit per
    // unit of time, e.g., EUR/hour)
    const PriceValue_T lValueOfTime (DEFAULT_VALUE_OF_TIME);

    // Restrictions
    const ChangeFees_T lChangeFees = false;
    const Disutility_T lChangeFeeDisutility = 30;
    const NonRefundable_T lNonRefundable = false;
    const Disutility_T lNonRefundableDisutility = 50;

    // Creation of the booking request structure
    BookingRequestStruct oBookingRequest (lOrigin, lDestination, lPOS,
                                          lPreferredDepartureDate,
                                          lRequestDateTime,
                                          lPreferredCabin,
                                          lPartySize, lChannel,
                                          lTripType, lStayDuration,
                                          lFrequentFlyerType,
                                          lPreferredDepartureTime,
                                          lWTP, lValueOfTime,
                                          lChangeFees, lChangeFeeDisutility,
                                          lNonRefundable,
                                          lNonRefundableDisutility);

    return oBookingRequest;
  }

  // //////////////////////////////////////////////////////////////////////
  BookingRequestStruct CmdBomManager::buildSampleBookingRequestForCRS() {
    // Origin
    const AirportCode_T lOrigin (AIRPORT_SIN);

    // Destination
    const AirportCode_T lDestination (AIRPORT_BKK);

    // Point of Sale (POS)
    const CityCode_T lPOS (POS_SIN);

    // Preferred departure date (30-JAN-2010)
    const Date_T lPreferredDepartureDate (2010, boost::gregorian::Jan, 30);

    // Preferred departure time (10:00)
    const Duration_T lPreferredDepartureTime (10, 0, 0);

    // Date of the request (22-JAN-2010)
    const Date_T lRequestDate (2010, boost::gregorian::Jan, 22);

    // Time of the request (10:00)
    const Duration_T lRequestTime (10, 0, 0);

    // Date-time of the request (made of the date and time above)
    const DateTime_T lRequestDateTime (lRequestDate, lRequestTime);

    // Preferred cabin (also named class of service sometimes)
    const CabinCode_T lPreferredCabin (CABIN_ECO);

    // Number of persons in the party
    const PartySize_T lPartySize (3);

    // Channel (direct/indirect, on-line/off-line)
    const ChannelLabel_T lChannel (CHANNEL_IN);

    // Type of the trip (one-way, inbound/outbound of a return trip)
    const TripType_T lTripType (TRIP_TYPE_INBOUND);

    // Duration of the stay (expressed as a number of days)
    const DayDuration_T lStayDuration (DEFAULT_STAY_DURATION);

    // Frequent flyer tier (member, silver, gold, platinum, senator, etc)
    const FrequentFlyer_T lFrequentFlyerType (FREQUENT_FLYER_MEMBER);

    // Maximum willing-to-pay (WTP, expressed in monetary unit, e.g., EUR)
    const WTP_T lWTP (DEFAULT_WTP);

    // Value of time, for the customer (expressed in monetary unit per
    // unit of time, e.g., EUR/hour)
    const PriceValue_T lValueOfTime (DEFAULT_VALUE_OF_TIME);

    // Restrictions
    const ChangeFees_T lChangeFees = true;
    const Disutility_T lChangeFeeDisutility = 50;
    const NonRefundable_T lNonRefundable = true;
    const Disutility_T lNonRefundableDisutility = 50;
    
    // Creation of the booking request structure
    BookingRequestStruct oBookingRequest (lOrigin,
                                          lDestination,
                                          lPOS,
                                          lPreferredDepartureDate,
                                          lRequestDateTime,
                                          lPreferredCabin,
                                          lPartySize, lChannel,
                                          lTripType, lStayDuration,
                                          lFrequentFlyerType,
                                          lPreferredDepartureTime,
                                          lWTP, lValueOfTime,
                                          lChangeFees, lChangeFeeDisutility,
                                          lNonRefundable,
                                          lNonRefundableDisutility);

    return oBookingRequest;
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::
  buildPartnershipsSampleInventoryAndRM (BomRoot& ioBomRoot) {
    
    // Step 0.1: Inventory level
    // Create an Inventory for SQ
    const AirlineCode_T lAirlineCodeSQ ("SQ");
    const InventoryKey lSQKey (lAirlineCodeSQ);
    Inventory& lSQInv = FacBom<Inventory>::instance().create (lSQKey);
    FacBomManager::addToListAndMap (ioBomRoot, lSQInv);
    FacBomManager::linkWithParent (ioBomRoot, lSQInv);

    // Add the airline feature object to the SQ inventory
    const AirlineFeatureKey lAirlineFeatureSQKey (lAirlineCodeSQ);
    AirlineFeature& lAirlineFeatureSQ =
      FacBom<AirlineFeature>::instance().create (lAirlineFeatureSQKey);
    FacBomManager::setAirlineFeature (lSQInv, lAirlineFeatureSQ);
    FacBomManager::linkWithParent (lSQInv, lAirlineFeatureSQ);
    // Link the airline feature object with the top of the BOM tree
    FacBomManager::addToListAndMap (ioBomRoot, lAirlineFeatureSQ);
    
    // Create an Inventory for CX
    const AirlineCode_T lAirlineCodeCX ("CX");
    const InventoryKey lCXKey (lAirlineCodeCX);
    Inventory& lCXInv = FacBom<Inventory>::instance().create (lCXKey);
    FacBomManager::addToListAndMap (ioBomRoot, lCXInv);
    FacBomManager::linkWithParent (ioBomRoot, lCXInv);

    // Add the airline feature object to the CX inventory
    const AirlineFeatureKey lAirlineFeatureCXKey (lAirlineCodeCX);
    AirlineFeature& lAirlineFeatureCX =
      FacBom<AirlineFeature>::instance().create (lAirlineFeatureCXKey);
    FacBomManager::setAirlineFeature (lCXInv, lAirlineFeatureCX);
    FacBomManager::linkWithParent (lCXInv, lAirlineFeatureCX);
    // Link the airline feature object with the top of the BOM tree
    FacBomManager::addToListAndMap (ioBomRoot, lAirlineFeatureCX);
    
    // ////// SQ ///////    
    // Step 0.2: Flight-date level
    // Create a FlightDate (SQ11/08-MAR-2010) for SQ's Inventory
    FlightNumber_T lFlightNumber = 11;
    Date_T lDate (2010, 3, 8);
    FlightDateKey lFlightDateKey (lFlightNumber, lDate);

    FlightDate& lSQ11_20100308_FD =
      FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lSQInv, lSQ11_20100308_FD);
    FacBomManager::linkWithParent (lSQInv, lSQ11_20100308_FD);

    // Create a (mkt) FlightDate (SQ1200/08-MAR-2010) for SQ's Inventory
    FlightNumber_T lMktFlightNumber = 1200;
    //lDate = Date_T (2010, 3, 8);
    FlightDateKey lMktFlightDateKey (lMktFlightNumber, lDate);

    FlightDate& lSQ1200_20100308_FD =
      FacBom<FlightDate>::instance().create (lMktFlightDateKey);
    FacBomManager::addToListAndMap (lSQInv, lSQ1200_20100308_FD);
    FacBomManager::linkWithParent (lSQInv, lSQ1200_20100308_FD);
    
    // Display the flight-date
    // STDAIR_LOG_DEBUG ("FlightDate: " << lBA9_20110610_FD.toString());
    
    // Step 0.3: Segment-date level
    // Create a first SegmentDate (SIN-BKK) for SQ's Inventory
    const AirportCode_T lSIN ("SIN");
    const AirportCode_T lBKK ("BKK");
    const DateOffset_T l1Day (1);
    const DateOffset_T l2Days (2);
    const Duration_T l0820 (8, 20, 0);
    const Duration_T l1100 (11, 0, 0);
    const Duration_T l0340 (3, 40, 0);
    SegmentDateKey lSegmentDateKey (lSIN, lBKK);

    SegmentDate& lSINBKKSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lSQ11_20100308_FD, lSINBKKSegment);
    FacBomManager::linkWithParent (lSQ11_20100308_FD, lSINBKKSegment);

    // Add the routing leg key to the SIN-BKK segment.
    const std::string lSQSINRoutingLegStr = "SQ;11;2010-Mar-8;SIN";
    lSINBKKSegment.addLegKey (lSQSINRoutingLegStr);

    // Fill the SegmentDate content
    lSINBKKSegment.setBoardingDate (lDate);
    lSINBKKSegment.setOffDate (lDate);
    lSINBKKSegment.setBoardingTime (l0820);
    lSINBKKSegment.setOffTime (l1100);
    lSINBKKSegment.setElapsedTime (l0340);

    // Create a second (mkt) SegmentDate (BKK-HKG) for SQ's Inventory
    const AirportCode_T lHKG ("HKG");
    const Duration_T l1200 (12, 0, 0);
    const Duration_T l1540 (15, 40, 0);
    const Duration_T l0240 (2, 40, 0);
    SegmentDateKey lMktSegmentDateKey (lBKK, lHKG);

    SegmentDate& lMktBKKHKGSegment =
      FacBom<SegmentDate>::instance().create (lMktSegmentDateKey);
    FacBomManager::addToListAndMap (lSQ1200_20100308_FD, lMktBKKHKGSegment);
    FacBomManager::linkWithParent (lSQ1200_20100308_FD, lMktBKKHKGSegment); 

    // Add the routing leg key CX;12;2010-Mar-8;BKK to the marketing
    // SQ;1200;2010-Mar-8;BKK-HKG segment.
    const std::string lCXBKKRoutingLegStr = "CX;12;2010-Mar-8;BKK";
    lMktBKKHKGSegment.addLegKey (lCXBKKRoutingLegStr);

    // Fill the (mkt) SegmentDate content
    lMktBKKHKGSegment.setBoardingDate (lDate);
    lMktBKKHKGSegment.setOffDate (lDate);
    lMktBKKHKGSegment.setBoardingTime (l1200);
    lMktBKKHKGSegment.setOffTime (l1540);
    lMktBKKHKGSegment.setElapsedTime (l0240);

    // Step 0.4: Leg-date level
    // Create a first LegDate (SIN) for SQ's Inventory
    LegDateKey lLegDateKey (lSIN);

    LegDate& lSINLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lSQ11_20100308_FD, lSINLeg);
    FacBomManager::linkWithParent (lSQ11_20100308_FD, lSINLeg);

    // Fill the LegDate content
    lSINLeg.setOffPoint (lBKK);
    lSINLeg.setBoardingDate (lDate);
    lSINLeg.setOffDate (lDate);
    lSINLeg.setBoardingTime (l0820);
    lSINLeg.setOffTime (l1100);
    lSINLeg.setElapsedTime (l0340);

    // Step 0.5: segment-cabin level
    // Create a SegmentCabin (Y) for the Segment SIN-BKK of SQ's Inventory
    const CabinCode_T lY ("Y");
    SegmentCabinKey lYSegmentCabinKey (lY);

    SegmentCabin& lSINBKKSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lSINBKKSegment, lSINBKKSegmentYCabin);
    FacBomManager::linkWithParent (lSINBKKSegment, lSINBKKSegmentYCabin);

    // Create a SegmentCabin (Y) for the (mkt) Segment BKK-HKG of SQ's Inventory
    SegmentCabin& lMktBKKHKGSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lMktBKKHKGSegment, lMktBKKHKGSegmentYCabin);
    FacBomManager::linkWithParent (lMktBKKHKGSegment, lMktBKKHKGSegmentYCabin);


    // Step 0.6: leg-cabin level
    // Create a LegCabin (Y) for the Leg SIN-BKK on SQ's Inventory
    LegCabinKey lYLegCabinKey (lY);

    LegCabin& lSINLegYCabin =
      FacBom<LegCabin>::instance().create (lYLegCabinKey);
    FacBomManager::addToListAndMap (lSINLeg, lSINLegYCabin);
    FacBomManager::linkWithParent (lSINLeg, lSINLegYCabin);

    CabinCapacity_T lCapacity (100);
    lSINLegYCabin.setCapacities (lCapacity);
    lSINLegYCabin.setAvailabilityPool (lCapacity);


    // Step 0.7: fare family level
    // Create a FareFamily (1) for the Segment SIN-BKK, cabin Y on SQ's Inv
    const FamilyCode_T l1 ("EcoSaver");
    FareFamilyKey l1FareFamilyKey (l1);

    FareFamily& lSINBKKSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin1Family);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin,
                                   lSINBKKSegmentYCabin1Family);

    // Create a FareFamily (1) for the (mkt) Segment BKK-HKG, cabin Y on SQ's Inv
    FareFamily& lMktBKKHKGSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lMktBKKHKGSegmentYCabin,
                                    lMktBKKHKGSegmentYCabin1Family);
    FacBomManager::linkWithParent (lMktBKKHKGSegmentYCabin,
                                    lMktBKKHKGSegmentYCabin1Family);
    
    // Step 0.8: booking class level
    // Create a BookingClass (Y) for the Segment SIN-BKK, cabin Y,
    // fare family 1 on SQ's Inv
    BookingClassKey lYBookingClassKey (lY);

    BookingClass& lSINBKKSegmentYCabin1FamilyYClass =
      FacBom<BookingClass>::instance().create (lYBookingClassKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin1Family,
                                    lSINBKKSegmentYCabin1FamilyYClass);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin1Family,
                                   lSINBKKSegmentYCabin1FamilyYClass);

    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin1FamilyYClass);
    FacBomManager::addToListAndMap (lSINBKKSegment,
                                    lSINBKKSegmentYCabin1FamilyYClass);

    lSINBKKSegmentYCabin1FamilyYClass.setYield(700);

    // Create a BookingClass (Y) for the (mkt) Segment BKK-HKG, cabin Y,
    // fare family 1 on SQ's Inv
    BookingClass& lMktBKKHKGSegmentYCabin1FamilyYClass =
      FacBom<BookingClass>::instance().create (lYBookingClassKey);
    FacBomManager::addToListAndMap (lMktBKKHKGSegmentYCabin1Family,
                                    lMktBKKHKGSegmentYCabin1FamilyYClass);
    FacBomManager::linkWithParent (lMktBKKHKGSegmentYCabin1Family,
                                   lMktBKKHKGSegmentYCabin1FamilyYClass);

    FacBomManager::addToListAndMap (lMktBKKHKGSegmentYCabin,
                                    lMktBKKHKGSegmentYCabin1FamilyYClass);
    FacBomManager::addToListAndMap (lMktBKKHKGSegment,
                                    lMktBKKHKGSegmentYCabin1FamilyYClass);

    lMktBKKHKGSegmentYCabin1FamilyYClass.setYield(700);

   
    // Create a BookingClass (M) for the Segment SIN-BKK, cabin Y,
    // fare family 1 on SQ's Inv
    const ClassCode_T lM ("M");
    BookingClassKey lMBookingClassKey (lM);

    BookingClass& lSINBKKSegmentYCabin1FamilyMClass =
      FacBom<BookingClass>::instance().create (lMBookingClassKey);
    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin1Family,
                                    lSINBKKSegmentYCabin1FamilyMClass);
    FacBomManager::linkWithParent (lSINBKKSegmentYCabin1Family,
                                   lSINBKKSegmentYCabin1FamilyMClass);

    FacBomManager::addToListAndMap (lSINBKKSegmentYCabin,
                                    lSINBKKSegmentYCabin1FamilyMClass);
    FacBomManager::addToListAndMap (lSINBKKSegment,
                                    lSINBKKSegmentYCabin1FamilyMClass);

    lSINBKKSegmentYCabin1FamilyMClass.setYield(500);

    // Create a BookingClass (M) for the (mkt) Segment BKK-HKG, cabin Y,
    // fare family 1 on SQ's Inv
    BookingClass& lMktBKKHKGSegmentYCabin1FamilyMClass =
      FacBom<BookingClass>::instance().create (lMBookingClassKey);
    FacBomManager::addToListAndMap (lMktBKKHKGSegmentYCabin1Family,
                                    lMktBKKHKGSegmentYCabin1FamilyMClass);
    FacBomManager::linkWithParent (lMktBKKHKGSegmentYCabin1Family,
                                   lMktBKKHKGSegmentYCabin1FamilyMClass);

    FacBomManager::addToListAndMap (lMktBKKHKGSegmentYCabin,
                                    lMktBKKHKGSegmentYCabin1FamilyMClass);
    FacBomManager::addToListAndMap (lMktBKKHKGSegment,
                                    lMktBKKHKGSegmentYCabin1FamilyMClass);

    lMktBKKHKGSegmentYCabin1FamilyMClass.setYield(500);
    
    /* =================================================================================== */

    // Step 1.0: O&D level
    // Create an O&D Date (SQ11/08-MAR-2010/SIN-BKK-SQ1200/08-MAR-2010/BKK-HKG)
    // for SQ's Inventory
    OnDString_T lSQSINBKKOnDStr = "SQ;11,2010-Mar-08;SIN,BKK";
    OnDString_T lMktSQBKKHKGOnDStr = "SQ;1200,2010-Mar-08;BKK,HKG";
    OnDStringList_T lOnDStringList;
    lOnDStringList.push_back (lSQSINBKKOnDStr);
    lOnDStringList.push_back (lMktSQBKKHKGOnDStr);

    OnDDateKey lOnDDateKey (lOnDStringList);
    OnDDate& lSQ_SINHKG_OnDDate =
      FacBom<OnDDate>::instance().create (lOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lSQInv, lSQ_SINHKG_OnDDate);
    FacBomManager::linkWithParent (lSQInv, lSQ_SINHKG_OnDDate);

    // Add the segments
    FacBomManager::addToListAndMap (lSQ_SINHKG_OnDDate, lSINBKKSegment);
    FacBomManager::addToListAndMap (lSQ_SINHKG_OnDDate, lMktBKKHKGSegment);

    // Add total forecast info for cabin Y.
    const MeanStdDevPair_T lMean60StdDev6 (60.0, 6.0);
    const WTP_T lWTP750 = 750.0;
    const WTPDemandPair_T lWTP750Mean60StdDev6 (lWTP750, lMean60StdDev6);
    lSQ_SINHKG_OnDDate.setTotalForecast (lY, lWTP750Mean60StdDev6);

    // Add demand info (optional).
    // 2 legs here, so 2 CabinClassPair to add in the list.
    // Fist leg: cabin Y, class M.
    CabinClassPair_T lCC_YM1 (lY,lM);
    // Second leg: cabin Y, class M too.
    CabinClassPair_T lCC_YM2 (lY,lM);
    CabinClassPairList_T lCabinClassPairList;
    lCabinClassPairList.push_back(lCC_YM1);
    lCabinClassPairList.push_back(lCC_YM2);
    const MeanStdDevPair_T lMean20StdDev2 (20.0, 2.0);
    const Yield_T lYield850 = 850.0;
    const YieldDemandPair_T lYield850Mean20StdDev2 (lYield850, lMean20StdDev2);
    lSQ_SINHKG_OnDDate.setDemandInformation (lCabinClassPairList, lYield850Mean20StdDev2);
    
    CabinClassPair_T lCC_YY1 (lY,lY);
    CabinClassPair_T lCC_YY2 (lY,lY);
    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YY1);
    lCabinClassPairList.push_back(lCC_YY2);
    const MeanStdDevPair_T lMean10StdDev1 (10.0, 1.0);
    const Yield_T lYield1200 = 1200.0;
    const YieldDemandPair_T lYield1200Mean10StdDev1 (lYield1200, 
                                                     lMean10StdDev1);
    lSQ_SINHKG_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield1200Mean10StdDev1);

    // Create an O&D Date (SQ11/08-MAR-2010/SIN-BKK) for SQ's Inventory
    lOnDStringList.clear();
    lOnDStringList.push_back (lSQSINBKKOnDStr);

    lOnDDateKey = OnDDateKey(lOnDStringList);
    OnDDate& lSQ_SINBKK_OnDDate =
      FacBom<OnDDate>::instance().create (lOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lSQInv, lSQ_SINBKK_OnDDate);
    FacBomManager::linkWithParent (lSQInv, lSQ_SINBKK_OnDDate);

    // Add the segments
    FacBomManager::addToListAndMap (lSQ_SINBKK_OnDDate, lSINBKKSegment);

    // Add total forecast info for cabin Y.
    const WTP_T lWTP400 = 400.0;
    const WTPDemandPair_T lWTP400Mean60StdDev6 (lWTP400, lMean60StdDev6);
    lSQ_SINBKK_OnDDate.setTotalForecast (lY, lWTP400Mean60StdDev6);

    // Add demand info (optional).
    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YM1);
    const MeanStdDevPair_T lMean20StdDev1 (20.0, 1.0);
    const Yield_T lYield500 = 500.0;
    const YieldDemandPair_T lYield500Mean20StdDev1 (lYield500, lMean20StdDev1);
    lSQ_SINBKK_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield500Mean20StdDev1);

    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YY1);
    const Yield_T lYield700 = 700.0;
    const YieldDemandPair_T lYield700Mean20StdDev1 (lYield700, lMean10StdDev1 );
    lSQ_SINBKK_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield700Mean20StdDev1);

    /*******************************************************************************
    // Create an O&D Date (SQ1200/08-MAR-2010/BKK-HKG) for SQ's Inventory
    lFullKeyList.clear();
    lFullKeyList.push_back (lMktSQBKKHKGFullKeyStr);

    lOnDDateKey = OnDDateKey(lFullKeyList);
    OnDDate& lMktSQ_BKKHKG_OnDDate =
      FacBom<OnDDate>::instance().create (lOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lSQInv, lMktSQ_BKKHKG_OnDDate);
    FacBomManager::linkWithParent (lSQInv, lMktSQ_BKKHKG_OnDDate);

    // Add the segments
    FacBomManager::addToListAndMap (lMktSQ_BKKHKG_OnDDate, lMktBKKHKGSegment);

    // Demand info is not added for purely marketed O&Ds
    // Add demand info
    // lCabinClassPairList.clear();
    // lCabinClassPairList.push_back(lCC_YM2);
    // lMktSQ_BKKHKG_OnDDate.setDemandInformation (lCabinClassPairList, 500.0, 20.0, 1.0);
    ***********************************************************************************/

    
    // ////// CX ///////    
    // Step 0.2: Flight-date level
    // Create a FlightDate (CX12/08-MAR-2010) for CX's Inventory
    lFlightNumber = 12;
    //lDate = Date_T (2010, 2, 8);
    lFlightDateKey = FlightDateKey (lFlightNumber, lDate);

    FlightDate& lCX12_20100308_FD =
      FacBom<FlightDate>::instance().create (lFlightDateKey);
    FacBomManager::addToListAndMap (lCXInv, lCX12_20100308_FD);
    FacBomManager::linkWithParent (lCXInv, lCX12_20100308_FD);

    // Create a (mkt) FlightDate (CX1100/08-FEB-2010) for CX's Inventory
    lFlightNumber = 1100;
    //lDate = Date_T (2010, 2, 8);
    lMktFlightDateKey = FlightDateKey (lFlightNumber, lDate);

    FlightDate& lCX1100_20100308_FD =
      FacBom<FlightDate>::instance().create (lMktFlightDateKey);
    FacBomManager::addToListAndMap (lCXInv, lCX1100_20100308_FD);
    FacBomManager::linkWithParent (lCXInv, lCX1100_20100308_FD);
    
    // Display the flight-date
    // STDAIR_LOG_DEBUG ("FlightDate: " << lAF084_20110320_FD.toString());

    // Step 0.3: Segment-date level
    // Create a SegmentDate BKK-HKG for CX's Inventory
    
    lSegmentDateKey = SegmentDateKey (lBKK, lHKG);

    SegmentDate& lBKKHKGSegment =
      FacBom<SegmentDate>::instance().create (lSegmentDateKey);
    FacBomManager::addToListAndMap (lCX12_20100308_FD, lBKKHKGSegment);
    FacBomManager::linkWithParent (lCX12_20100308_FD, lBKKHKGSegment);  

    // Add the routing leg key to the marketing BKK-HKG segment.
    lBKKHKGSegment.addLegKey (lCXBKKRoutingLegStr);

    // Fill the SegmentDate content
    lBKKHKGSegment.setBoardingDate (lDate);
    lBKKHKGSegment.setOffDate (lDate);
    lBKKHKGSegment.setBoardingTime (l1200);
    lBKKHKGSegment.setOffTime (l1540);
    lBKKHKGSegment.setElapsedTime (l0240);

    // Create a second (mkt) SegmentDate (SIN-BKK) for CX's Inventory
    lMktSegmentDateKey = SegmentDateKey (lSIN, lBKK);

    SegmentDate& lMktSINBKKSegment =
      FacBom<SegmentDate>::instance().create (lMktSegmentDateKey);
    FacBomManager::addToListAndMap (lCX1100_20100308_FD, lMktSINBKKSegment);
    FacBomManager::linkWithParent (lCX1100_20100308_FD, lMktSINBKKSegment);

    // Add the routing leg key SQ;11;2010-Mar-8;SIN to the marketing
    // CX;1100;2010-Mar-8;SIN-BKK segment.
    lMktSINBKKSegment.addLegKey (lSQSINRoutingLegStr);

    // Fill the (mkt) SegmentDate content
    lMktSINBKKSegment.setBoardingDate (lDate);
    lMktSINBKKSegment.setOffDate (lDate);
    lMktSINBKKSegment.setBoardingTime (l0820);
    lMktSINBKKSegment.setOffTime (l1100);
    lMktSINBKKSegment.setElapsedTime (l0340);

    // Step 0.4: Leg-date level
    // Create a LegDate (BKK) for CX's Inventory
    lLegDateKey = LegDateKey (lBKK);

    LegDate& lBKKLeg = FacBom<LegDate>::instance().create (lLegDateKey);
    FacBomManager::addToListAndMap (lCX12_20100308_FD, lBKKLeg);
    FacBomManager::linkWithParent (lCX12_20100308_FD, lBKKLeg);

    // Fill the LegDate content
    lBKKLeg.setOffPoint (lHKG);
    lBKKLeg.setBoardingDate (lDate);
    lBKKLeg.setOffDate (lDate);
    lBKKLeg.setBoardingTime (l1200);
    lBKKLeg.setOffTime (l1540);
    lBKKLeg.setElapsedTime (l0240);

    // Display the leg-date
    // STDAIR_LOG_DEBUG ("LegDate: " << lCDGLeg.toString());

    // Step 0.5: segment-cabin level
    // Create a SegmentCabin (Y) for the Segment BKK-HKG of CX's Inventory
    SegmentCabin& lBKKHKGSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lBKKHKGSegment, lBKKHKGSegmentYCabin);
    FacBomManager::linkWithParent (lBKKHKGSegment, lBKKHKGSegmentYCabin);

    // Create a SegmentCabin (Y) for the (mkt) Segment SIN-BKK of CX's Inventory
    SegmentCabin& lMktSINBKKSegmentYCabin =
      FacBom<SegmentCabin>::instance().create (lYSegmentCabinKey);
    FacBomManager::addToListAndMap (lMktSINBKKSegment, lMktSINBKKSegmentYCabin);
    FacBomManager::linkWithParent (lMktSINBKKSegment, lMktSINBKKSegmentYCabin);

    // Step 0.6: leg-cabin level
    // Create a LegCabin (Y) for the Leg BKK-HKG on CX's Inventory
    LegCabin& lBKKLegYCabin =
      FacBom<LegCabin>::instance().create (lYLegCabinKey);
    FacBomManager::addToListAndMap (lBKKLeg, lBKKLegYCabin);
    FacBomManager::linkWithParent (lBKKLeg, lBKKLegYCabin);

    lCapacity = CabinCapacity_T(100);
    lBKKLegYCabin.setCapacities (lCapacity);
    lBKKLegYCabin.setAvailabilityPool (lCapacity);

    // Step 0.7: fare family level
    // Create a fareFamily (1) for the Segment BKK-HKG, cabin Y on CX's Inv
    FareFamily& lBKKHKGSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lBKKHKGSegmentYCabin,
                                    lBKKHKGSegmentYCabin1Family);
    FacBomManager::linkWithParent (lBKKHKGSegmentYCabin,
                                   lBKKHKGSegmentYCabin1Family);

    // Create a FareFamily (1) for the (mkt) Segment SIN-BKK, cabin Y on CX's Inv
    FareFamily& lMktSINBKKSegmentYCabin1Family =
      FacBom<FareFamily>::instance().create (l1FareFamilyKey);
    FacBomManager::addToListAndMap (lMktSINBKKSegmentYCabin,
                                    lMktSINBKKSegmentYCabin1Family);
    FacBomManager::linkWithParent (lMktSINBKKSegmentYCabin,
                                   lMktSINBKKSegmentYCabin1Family);

    
    // Step 0.8: booking class level
    // Create a BookingClass (Y) for the
    // Segment BKK-HKG, cabin Y, fare family 1 on CX's Inv
    BookingClass& lBKKHKGSegmentYCabin1FamilyYClass =
      FacBom<BookingClass>::instance().create (lYBookingClassKey);
    FacBomManager::addToListAndMap (lBKKHKGSegmentYCabin1Family,
                                    lBKKHKGSegmentYCabin1FamilyYClass);
    FacBomManager::linkWithParent (lBKKHKGSegmentYCabin1Family,
                                   lBKKHKGSegmentYCabin1FamilyYClass);

    FacBomManager::addToListAndMap (lBKKHKGSegmentYCabin,
                                    lBKKHKGSegmentYCabin1FamilyYClass);
    FacBomManager::addToListAndMap (lBKKHKGSegment,
                                    lBKKHKGSegmentYCabin1FamilyYClass);

    lBKKHKGSegmentYCabin1FamilyYClass.setYield(700);

    // Create a BookingClass (Y) for the (mkt) Segment SIN-BKK, cabin Y,
    // fare family 1 on CX's Inv
    BookingClass& lMktSINBKKSegmentYCabin1FamilyYClass =
      FacBom<BookingClass>::instance().create (lYBookingClassKey);
    FacBomManager::addToListAndMap (lMktSINBKKSegmentYCabin1Family,
                                    lMktSINBKKSegmentYCabin1FamilyYClass);
    FacBomManager::linkWithParent (lMktSINBKKSegmentYCabin1Family,
                                   lMktSINBKKSegmentYCabin1FamilyYClass);

    FacBomManager::addToListAndMap (lMktSINBKKSegmentYCabin,
                                    lMktSINBKKSegmentYCabin1FamilyYClass);
    FacBomManager::addToListAndMap (lMktSINBKKSegment,
                                    lMktSINBKKSegmentYCabin1FamilyYClass);

    lMktSINBKKSegmentYCabin1FamilyYClass.setYield(700);
    
    //Create a BookingClass (M) for the
    // Segment BKK-HKG, cabin Y, fare family 1 on CX's Inv
    BookingClass& lBKKHKGSegmentYCabin1FamilyMClass =
      FacBom<BookingClass>::instance().create (lMBookingClassKey);
    FacBomManager::addToListAndMap (lBKKHKGSegmentYCabin1Family,
                                    lBKKHKGSegmentYCabin1FamilyMClass);
    FacBomManager::linkWithParent (lBKKHKGSegmentYCabin1Family,
                                   lBKKHKGSegmentYCabin1FamilyMClass);

    FacBomManager::addToListAndMap (lBKKHKGSegmentYCabin,
                                    lBKKHKGSegmentYCabin1FamilyMClass);
    FacBomManager::addToListAndMap (lBKKHKGSegment,
                                    lBKKHKGSegmentYCabin1FamilyMClass);

    lBKKHKGSegmentYCabin1FamilyMClass.setYield(500);

    // Create a BookingClass (M) for the (mkt) Segment SIN-BKK, cabin Y,
    // fare family 1 on CX's Inv
    BookingClass& lMktSINBKKSegmentYCabin1FamilyMClass =
      FacBom<BookingClass>::instance().create (lMBookingClassKey);
    FacBomManager::addToListAndMap (lMktSINBKKSegmentYCabin1Family,
                                    lMktSINBKKSegmentYCabin1FamilyMClass);
    FacBomManager::linkWithParent (lMktSINBKKSegmentYCabin1Family,
                                   lMktSINBKKSegmentYCabin1FamilyMClass);

    FacBomManager::addToListAndMap (lMktSINBKKSegmentYCabin,
                                    lMktSINBKKSegmentYCabin1FamilyMClass);
    FacBomManager::addToListAndMap (lMktSINBKKSegment,
                                    lMktSINBKKSegmentYCabin1FamilyMClass);

    lMktSINBKKSegmentYCabin1FamilyMClass.setYield(500);

    /* =================================================================================== */

    // Step 1.0: O&D level
    // Create an O&D Date (CX1100/08-MAR-2010/SIN-BKK-CX12/08-MAR-2010/BKK-HKG) for CX's Inventory
    OnDString_T lMktCXSINBKKOnDStr = "CX;1100,2010-Mar-08;SIN,BKK";
    OnDString_T lCXBKKHKGOnDStr = "CX;12,2010-Mar-08;BKK,HKG";
    lOnDStringList.clear();
    lOnDStringList.push_back (lMktCXSINBKKOnDStr);
    lOnDStringList.push_back (lCXBKKHKGOnDStr);

    lOnDDateKey = OnDDateKey(lOnDStringList);
    OnDDate& lCX_SINHKG_OnDDate =
      FacBom<OnDDate>::instance().create (lOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lCXInv, lCX_SINHKG_OnDDate);
    FacBomManager::linkWithParent (lCXInv, lCX_SINHKG_OnDDate);

    // Add the segments
    FacBomManager::addToListAndMap (lCX_SINHKG_OnDDate, lMktSINBKKSegment);
    FacBomManager::addToListAndMap (lCX_SINHKG_OnDDate, lBKKHKGSegment);

    // Add total forecast info for cabin Y.
    lCX_SINHKG_OnDDate.setTotalForecast (lY, lWTP750Mean60StdDev6);
    
    // Add demand info
    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YM1);
    lCabinClassPairList.push_back(lCC_YM2);
    lCX_SINHKG_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield850Mean20StdDev2);

    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YY1);
    lCabinClassPairList.push_back(lCC_YY2);
    lCX_SINHKG_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield1200Mean10StdDev1);

    /***********************************************************************************
    // Create an O&D Date (CX1100/08-MAR-2010/SIN-BKK) for CX's Inventory
    lFullKeyList.clear();
    lFullKeyList.push_back (lMktCXSINBKKFullKeyStr);

    lOnDDateKey = OnDDateKey(lFullKeyList);
    OnDDate& lMktCX_SINBKK_OnDDate =
      FacBom<OnDDate>::instance().create (lOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lCXInv, lMktCX_SINBKK_OnDDate);
    FacBomManager::linkWithParent (lCXInv, lMktCX_SINBKK_OnDDate);

    // Add the segments
    FacBomManager::addToListAndMap (lMktCX_SINBKK_OnDDate, lMktSINBKKSegment);

    // Demand info is not added for purely marketed O&Ds
    // Add demand info
    // lCabinClassPairList.clear();
    // lCabinClassPairList.push_back(lCC_YM1);
    // lMktCX_SINBKK_OnDDate.setDemandInformation (lCabinClassPairList, 500.0, 20.0, 1.0);
    *************************************************************************************/
    
    // Create an O&D Date (CX12/08-FEB-2010/BKK-HKG) for CX's Inventory
    lOnDStringList.clear();
    lOnDStringList.push_back (lCXBKKHKGOnDStr);

    lOnDDateKey = OnDDateKey(lOnDStringList);
    OnDDate& lCX_BKKHKG_OnDDate =
      FacBom<OnDDate>::instance().create (lOnDDateKey);
    // Link to the inventory
    FacBomManager::addToListAndMap (lCXInv, lCX_BKKHKG_OnDDate);
    FacBomManager::linkWithParent (lCXInv, lCX_BKKHKG_OnDDate);

    // Add the segments
    FacBomManager::addToListAndMap (lCX_BKKHKG_OnDDate, lBKKHKGSegment);

    // Add total forecast info for cabin Y.
    lCX_BKKHKG_OnDDate.setTotalForecast (lY, lWTP400Mean60StdDev6);

    // Add demand info
    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YM2);
    lCX_BKKHKG_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield500Mean20StdDev1);

    lCabinClassPairList.clear();
    lCabinClassPairList.push_back(lCC_YY2);
    const YieldDemandPair_T lYield700Mean10StdDev1 (lYield700, lMean10StdDev1 );
    lCX_BKKHKG_OnDDate.setDemandInformation (lCabinClassPairList, 
                                             lYield700Mean10StdDev1);

    /*================================================================================
      ================================================================================
      ================================================================================*/
    // Schedule:
    // SQ:
    // Step 1: flight period level
    // Create a flight period for SQ11:
    const DoWStruct lDoWSrtuct ("1111111");
    const Date_T lDateRangeStart (2010, boost::gregorian::Mar, 8);
    const Date_T lDateRangeEnd (2010, boost::gregorian::Mar, 9);
    const DatePeriod_T lDatePeriod (lDateRangeStart, lDateRangeEnd);
    const PeriodStruct lPeriodStruct (lDatePeriod,lDoWSrtuct);

    lFlightNumber = FlightNumber_T (11);

    FlightPeriodKey lFlightPeriodKey (lFlightNumber, lPeriodStruct);

    FlightPeriod& lSQ11FlightPeriod =
      FacBom<FlightPeriod>::instance().create (lFlightPeriodKey);
    FacBomManager::addToListAndMap (lSQInv, lSQ11FlightPeriod);
    FacBomManager::linkWithParent (lSQInv, lSQ11FlightPeriod);

    // Step 2: segment period level
    // Create a segment period for SIN-BKK:

    SegmentPeriodKey lSegmentPeriodKey (lSIN, lBKK);

    SegmentPeriod& lSINBKKSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lSegmentPeriodKey);
    FacBomManager::addToListAndMap (lSQ11FlightPeriod, lSINBKKSegmentPeriod);
    FacBomManager::linkWithParent (lSQ11FlightPeriod, lSINBKKSegmentPeriod);

    lSINBKKSegmentPeriod.setBoardingTime (l0820);
    lSINBKKSegmentPeriod.setOffTime (l1100);
    lSINBKKSegmentPeriod.setElapsedTime (l0340);
    ClassList_String_T lYM ("YM");
    lSINBKKSegmentPeriod.addCabinBookingClassList (lY,lYM);

    // CX:
    // Step 1: flight period level
    // Create a flight period for CX12:  
    lFlightNumber = FlightNumber_T (12);

    lFlightPeriodKey = FlightPeriodKey(lFlightNumber, lPeriodStruct);

    FlightPeriod& lCX12FlightPeriod =
      FacBom<FlightPeriod>::instance().create (lFlightPeriodKey);
    FacBomManager::addToListAndMap (lCXInv, lCX12FlightPeriod);
    FacBomManager::linkWithParent (lCXInv, lCX12FlightPeriod);

    // Step 2: segment period level
    // Create a segment period for BKK-HKG:

    lSegmentPeriodKey = SegmentPeriodKey (lBKK, lHKG);

    SegmentPeriod& lBKKHKGSegmentPeriod =
      FacBom<SegmentPeriod>::instance().create (lSegmentPeriodKey);
    FacBomManager::addToListAndMap (lCX12FlightPeriod, lBKKHKGSegmentPeriod);
    FacBomManager::linkWithParent (lCX12FlightPeriod, lBKKHKGSegmentPeriod);

    lBKKHKGSegmentPeriod.setBoardingTime (l1200);
    lBKKHKGSegmentPeriod.setOffTime (l1540);
    lBKKHKGSegmentPeriod.setElapsedTime (l0240);
    lBKKHKGSegmentPeriod.addCabinBookingClassList (lY,lYM);
    
  }

  // //////////////////////////////////////////////////////////////////////
  void CmdBomManager::buildPartnershipsSamplePricing (BomRoot& ioBomRoot) {


    /*===================================================================================*/
    // First airport pair SIN-BKK.
    // Set the airport-pair primary key.
    AirportPairKey lAirportPairKey ("SIN", "BKK");
    
    // Create the AirportPairKey object and link it to the ioBomRoot object.
    AirportPair& lSINBKKAirportPair =
      FacBom<AirportPair>::instance().create (lAirportPairKey);
    FacBomManager::addToListAndMap (ioBomRoot, lSINBKKAirportPair);
    FacBomManager::linkWithParent (ioBomRoot, lSINBKKAirportPair);

    // Set the fare date-period primary key.
    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);

    // Create the DatePeriodKey object and link it to the PosChannel object.
    DatePeriod& lSINBKKDatePeriod =
      FacBom<DatePeriod>::instance().create (lDatePeriodKey);
    FacBomManager::addToListAndMap (lSINBKKAirportPair, lSINBKKDatePeriod);
    FacBomManager::linkWithParent (lSINBKKAirportPair, lSINBKKDatePeriod);    

    // Set the point-of-sale-channel primary key.
    PosChannelKey lPosChannelKey ("SIN","IN");  
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lSINPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lSINBKKDatePeriod, lSINPosChannel);
    FacBomManager::linkWithParent (lSINBKKDatePeriod, lSINPosChannel);
   
    // Set the fare time-period primary key.
    const Time_T lTimeRangeStart (0, 0, 0);
    const Time_T lTimeRangeEnd (23, 0, 0);
    const TimePeriodKey lFareTimePeriodKey (lTimeRangeStart,
                                            lTimeRangeEnd);

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lSINBKKFareTimePeriod =
      FacBom<TimePeriod>::instance().create (lFareTimePeriodKey);
    FacBomManager::addToListAndMap (lSINPosChannel, lSINBKKFareTimePeriod);
    FacBomManager::linkWithParent (lSINPosChannel, lSINBKKFareTimePeriod); 

    // Generate the FareRule
    const FareFeaturesKey lFareFeaturesKey (TRIP_TYPE_ONE_WAY,
                                            NO_ADVANCE_PURCHASE,
                                            SATURDAY_STAY,
                                            CHANGE_FEES,
                                            NON_REFUNDABLE,
                                            NO_STAY_DURATION);

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lSINBKKFareFeatures =
      FacBom<FareFeatures>::instance().create (lFareFeaturesKey);
    FacBomManager::addToListAndMap (lSINBKKFareTimePeriod, lSINBKKFareFeatures);
    FacBomManager::linkWithParent (lSINBKKFareTimePeriod, lSINBKKFareFeatures);

    // Generate Segment Features and link them to their FareRule.
    AirlineCodeList_T lSQAirlineCodeList;
    lSQAirlineCodeList.push_back ("SQ");
    
    ClassList_StringList_T lYClassCodeList;
    lYClassCodeList.push_back ("Y");    
    const AirlineClassListKey lSQAirlineYClassListKey (lSQAirlineCodeList,
                                                       lYClassCodeList);

    ClassList_StringList_T lMClassCodeList;
    lMClassCodeList.push_back ("M");
    const AirlineClassListKey lSQAirlineMClassListKey (lSQAirlineCodeList,
                                                       lMClassCodeList);

    // Create the AirlineClassListKey and link it to the FareFeatures object.
    AirlineClassList& lSQAirlineYClassList =
      FacBom<AirlineClassList>::instance().create (lSQAirlineYClassListKey);
    lSQAirlineYClassList.setFare(700);
    FacBomManager::addToListAndMap (lSINBKKFareFeatures, lSQAirlineYClassList);
    FacBomManager::linkWithParent (lSINBKKFareFeatures, lSQAirlineYClassList);

    AirlineClassList& lSQAirlineMClassList =
      FacBom<AirlineClassList>::instance().create (lSQAirlineMClassListKey);
    lSQAirlineMClassList.setFare(500);
    FacBomManager::addToListAndMap (lSINBKKFareFeatures, lSQAirlineMClassList);
    FacBomManager::linkWithParent (lSINBKKFareFeatures, lSQAirlineMClassList);

    /*===================================================================================*/
    // Second airport pair BKK-HKG.
    // Set the airport-pair primary key.
    lAirportPairKey = AirportPairKey ("BKK", "HKG");
    
    // Create the AirportPairKey object and link it to the ioBomRoot object.
    AirportPair& lBKKHKGAirportPair =
      FacBom<AirportPair>::instance().create (lAirportPairKey);
    FacBomManager::addToListAndMap (ioBomRoot, lBKKHKGAirportPair);
    FacBomManager::linkWithParent (ioBomRoot, lBKKHKGAirportPair);

    // Set the fare date-period primary key.
    // Use the same as previously.

    // Create the DatePeriodKey object and link it to the PosChannel object.
    DatePeriod& lBKKHKGDatePeriod =
      FacBom<DatePeriod>::instance().create (lDatePeriodKey);
    FacBomManager::addToListAndMap (lBKKHKGAirportPair, lBKKHKGDatePeriod);
    FacBomManager::linkWithParent (lBKKHKGAirportPair, lBKKHKGDatePeriod);    

    // Set the point-of-sale-channel primary key.
    lPosChannelKey  = PosChannelKey("BKK","IN");  
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lBKKPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lBKKHKGDatePeriod, lBKKPosChannel);
    FacBomManager::linkWithParent (lBKKHKGDatePeriod, lBKKPosChannel);
   
    // Set the fare time-period primary key.
    // Use the same as previously.

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lBKKHKGFareTimePeriod =
      FacBom<TimePeriod>::instance().create (lFareTimePeriodKey);
    FacBomManager::addToListAndMap (lBKKPosChannel, lBKKHKGFareTimePeriod);
    FacBomManager::linkWithParent (lBKKPosChannel, lBKKHKGFareTimePeriod);

    // Generate the FareRule
    // Use the same key as previously.

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lBKKHKGFareFeatures =
      FacBom<FareFeatures>::instance().create (lFareFeaturesKey);
    FacBomManager::addToListAndMap (lBKKHKGFareTimePeriod, lBKKHKGFareFeatures);
    FacBomManager::linkWithParent (lBKKHKGFareTimePeriod, lBKKHKGFareFeatures);

    // Generate Segment Features and link them to their FareRule.
    AirlineCodeList_T lCXAirlineCodeList;
    lCXAirlineCodeList.push_back ("CX");
    
    const AirlineClassListKey lCXAirlineYClassListKey (lCXAirlineCodeList,
                                                       lYClassCodeList);

    const AirlineClassListKey lCXAirlineMClassListKey (lCXAirlineCodeList,
                                                       lMClassCodeList);

    // Create the AirlineClassListKey and link it to the FareFeatures object.
    AirlineClassList& lCXAirlineYClassList =
      FacBom<AirlineClassList>::instance().create (lCXAirlineYClassListKey);
    lCXAirlineYClassList.setFare(700);
    FacBomManager::addToListAndMap (lBKKHKGFareFeatures, lCXAirlineYClassList);
    FacBomManager::linkWithParent (lBKKHKGFareFeatures, lCXAirlineYClassList);
    
    AirlineClassList& lCXAirlineMClassList =
      FacBom<AirlineClassList>::instance().create (lCXAirlineMClassListKey);
    lCXAirlineMClassList.setFare(500);
    FacBomManager::addToListAndMap (lBKKHKGFareFeatures, lCXAirlineMClassList);
    FacBomManager::linkWithParent (lBKKHKGFareFeatures, lCXAirlineMClassList);

    /*===================================================================================*/
    // Third airport pair SIN-HKG.
    // Set the airport-pair primary key.
    lAirportPairKey = AirportPairKey ("SIN", "HKG");
    
    // Create the AirportPairKey object and link it to the ioBomRoot object.
    AirportPair& lSINHKGAirportPair =
      FacBom<AirportPair>::instance().create (lAirportPairKey);
    FacBomManager::addToListAndMap (ioBomRoot, lSINHKGAirportPair);
    FacBomManager::linkWithParent (ioBomRoot, lSINHKGAirportPair);

    // Set the fare date-period primary key.
    // Use the same as previously.

    // Create the DatePeriodKey object and link it to the PosChannel object.
    DatePeriod& lSINHKGDatePeriod =
      FacBom<DatePeriod>::instance().create (lDatePeriodKey);
    FacBomManager::addToListAndMap (lSINHKGAirportPair, lSINHKGDatePeriod);
    FacBomManager::linkWithParent (lSINHKGAirportPair, lSINHKGDatePeriod);    

    // Set the point-of-sale-channel primary key.
    lPosChannelKey = PosChannelKey("SIN","IN");  
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lOnDSINPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lSINHKGDatePeriod, lOnDSINPosChannel);
    FacBomManager::linkWithParent (lSINHKGDatePeriod, lOnDSINPosChannel);
   
    // Set the fare time-period primary key.
    // Use the same as previously.

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lSINHKGFareTimePeriod =
      FacBom<TimePeriod>::instance().create (lFareTimePeriodKey);
    FacBomManager::addToListAndMap (lOnDSINPosChannel, lSINHKGFareTimePeriod);
    FacBomManager::linkWithParent (lOnDSINPosChannel, lSINHKGFareTimePeriod);

    // Generate the FareRule
    // Use the same key as previously.

    // Create the FareFeaturesKey and link it to the TimePeriod object.
    FareFeatures& lSINHKGFareFeatures =
      FacBom<FareFeatures>::instance().create (lFareFeaturesKey);
    FacBomManager::addToListAndMap (lSINHKGFareTimePeriod, lSINHKGFareFeatures);
    FacBomManager::linkWithParent (lSINHKGFareTimePeriod, lSINHKGFareFeatures);

    // Generate Segment Features and link them to their FareRule.
    AirlineCodeList_T lSQ_CXAirlineCodeList;
    lSQ_CXAirlineCodeList.push_back ("SQ");
    lSQ_CXAirlineCodeList.push_back ("CX");

    ClassList_StringList_T lY_YClassCodeList;
    lY_YClassCodeList.push_back ("Y");
    lY_YClassCodeList.push_back ("Y");
    const AirlineClassListKey lSQ_CXAirlineYClassListKey (lSQ_CXAirlineCodeList,
                                                          lY_YClassCodeList);

    ClassList_StringList_T lM_MClassCodeList;
    lM_MClassCodeList.push_back ("M");
    lM_MClassCodeList.push_back ("M");
    const AirlineClassListKey lSQ_CXAirlineMClassListKey (lSQ_CXAirlineCodeList,
                                                          lM_MClassCodeList);

    // Create the AirlineClassListKey and link it to the FareFeatures object.
    AirlineClassList& lSQ_CXAirlineYClassList =
      FacBom<AirlineClassList>::instance().create (lSQ_CXAirlineYClassListKey);
    lSQ_CXAirlineYClassList.setFare(1200);
    FacBomManager::addToListAndMap (lSINHKGFareFeatures, 
                                    lSQ_CXAirlineYClassList);
    FacBomManager::linkWithParent (lSINHKGFareFeatures, 
                                   lSQ_CXAirlineYClassList);
    
    AirlineClassList& lSQ_CXAirlineMClassList =
      FacBom<AirlineClassList>::instance().create (lSQ_CXAirlineMClassListKey);
    lSQ_CXAirlineMClassList.setFare(850);
    FacBomManager::addToListAndMap (lSINHKGFareFeatures, 
                                    lSQ_CXAirlineMClassList);
    FacBomManager::linkWithParent (lSINHKGFareFeatures, 
                                   lSQ_CXAirlineMClassList);



    /*===================================================================================*/

    // Use the same airport pair, and date period for adding SQ SIN-BKK yields.
    
    // Set the point-of-sale-channel primary key.
    lPosChannelKey = PosChannelKey(DEFAULT_POS, DEFAULT_CHANNEL);  
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lRAC_SINBKKPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lSINBKKDatePeriod, lRAC_SINBKKPosChannel);
    FacBomManager::linkWithParent (lSINBKKDatePeriod, lRAC_SINBKKPosChannel);
   
    // Set the yield time-period primary key.
    const TimePeriodKey lYieldTimePeriodKey (lTimeRangeStart,
                                            lTimeRangeEnd);

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lSINBKKYieldTimePeriod =
      FacBom<TimePeriod>::instance().create (lYieldTimePeriodKey);
    FacBomManager::addToListAndMap (lRAC_SINBKKPosChannel, 
                                    lSINBKKYieldTimePeriod);
    FacBomManager::linkWithParent (lRAC_SINBKKPosChannel, 
                                   lSINBKKYieldTimePeriod);        

    // Generate the YieldRule
    const YieldFeaturesKey lYieldFeaturesKey (TRIP_TYPE_ONE_WAY,
                                              CABIN_Y);

    // Create the YieldFeaturesKey and link it to the TimePeriod object.
    YieldFeatures& lSINBKKYieldFeatures =
      FacBom<YieldFeatures>::instance().create (lYieldFeaturesKey);
    FacBomManager::addToListAndMap (lSINBKKYieldTimePeriod,
                                    lSINBKKYieldFeatures);
    FacBomManager::linkWithParent (lSINBKKYieldTimePeriod, 
                                   lSINBKKYieldFeatures);        

    // Generate Segment Features and link them to their YieldRule.
    // Use the same key as previously.

    // Create the AirlineClassListKey and link it to the YieldFeatures object.
    AirlineClassList& lRAC_SQAirlineYClassList =
      FacBom<AirlineClassList>::instance().create (lSQAirlineYClassListKey);
    lRAC_SQAirlineYClassList.setYield(700);
    FacBomManager::addToListAndMap (lSINBKKYieldFeatures, 
                                    lRAC_SQAirlineYClassList);
    FacBomManager::linkWithParent (lSINBKKYieldFeatures, 
                                   lRAC_SQAirlineYClassList);

    AirlineClassList& lRAC_SQAirlineMClassList =
      FacBom<AirlineClassList>::instance().create (lSQAirlineMClassListKey);
    lRAC_SQAirlineMClassList.setYield(500);
    FacBomManager::addToListAndMap (lSINBKKYieldFeatures, 
                                    lRAC_SQAirlineMClassList);
    FacBomManager::linkWithParent (lSINBKKYieldFeatures, 
                                   lRAC_SQAirlineMClassList);

    /*===================================================================================*/

    // Use the same airport pair, and date period for adding CX BKK-HKG yields. 
    
    // Set the point-of-sale-channel primary key.
    // Use the same as previously.
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lRAC_BKKHKGPosChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lBKKHKGDatePeriod, lRAC_BKKHKGPosChannel);
    FacBomManager::linkWithParent (lBKKHKGDatePeriod, lRAC_BKKHKGPosChannel);
   
    // Set the yield time-period primary key.
    // Use the same as previously.

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lBKKHKGYieldTimePeriod =
      FacBom<TimePeriod>::instance().create (lYieldTimePeriodKey);
    FacBomManager::addToListAndMap (lRAC_BKKHKGPosChannel, 
                                    lBKKHKGYieldTimePeriod);
    FacBomManager::linkWithParent (lRAC_BKKHKGPosChannel, 
                                   lBKKHKGYieldTimePeriod);        

    // Generate the YieldRule
    // Use the same key as previously.

    // Create the YieldFeaturesKey and link it to the TimePeriod object.
    YieldFeatures& lBKKHKGYieldFeatures =
      FacBom<YieldFeatures>::instance().create (lYieldFeaturesKey);
    FacBomManager::addToListAndMap (lBKKHKGYieldTimePeriod, 
                                    lBKKHKGYieldFeatures);
    FacBomManager::linkWithParent (lBKKHKGYieldTimePeriod, 
                                   lBKKHKGYieldFeatures);        

    // Generate Segment Features and link them to their YieldRule.
    // Use the same key as previously.

    // Create the AirlineClassListKey and link it to the YieldFeatures object.
    AirlineClassList& lRAC_CXAirlineYClassList =
      FacBom<AirlineClassList>::instance().create (lCXAirlineYClassListKey);
    lRAC_CXAirlineYClassList.setYield(700);
    FacBomManager::addToListAndMap (lBKKHKGYieldFeatures, 
                                    lRAC_CXAirlineYClassList);
    FacBomManager::linkWithParent (lBKKHKGYieldFeatures, 
                                   lRAC_CXAirlineYClassList);
    
    AirlineClassList& lRAC_CXAirlineMClassList =
      FacBom<AirlineClassList>::instance().create (lCXAirlineMClassListKey);
    lRAC_CXAirlineMClassList.setYield(500);
    FacBomManager::addToListAndMap (lBKKHKGYieldFeatures, 
                                    lRAC_CXAirlineMClassList);
    FacBomManager::linkWithParent (lBKKHKGYieldFeatures, 
                                   lRAC_CXAirlineMClassList);

    /*===================================================================================*/

    // Use the same airport pair, and date period for SQ-CX SIN-HKG

    // Set the point-of-sale-channel primary key.
    // Use the same as previously.
    
    // Create the PositionKey object and link it to the AirportPair object.
    PosChannel& lRAC_SINHKGChannel =
      FacBom<PosChannel>::instance().create (lPosChannelKey);
    FacBomManager::addToListAndMap (lSINHKGDatePeriod, lRAC_SINHKGChannel);
    FacBomManager::linkWithParent (lSINHKGDatePeriod, lRAC_SINHKGChannel);
   
    // Set the yield time-period primary key.
    // Use the same as previously.

    // Create the TimePeriodKey and link it to the DatePeriod object.
    TimePeriod& lSINHKGYieldTimePeriod =
      FacBom<TimePeriod>::instance().create (lYieldTimePeriodKey);
    FacBomManager::addToListAndMap (lRAC_SINHKGChannel, lSINHKGYieldTimePeriod);
    FacBomManager::linkWithParent (lRAC_SINHKGChannel, lSINHKGYieldTimePeriod);  

    // Generate the YieldRule
    // Use the same key as previously.

    // Create the YieldFeaturesKey and link it to the TimePeriod object.
    YieldFeatures& lSINHKGYieldFeatures =
      FacBom<YieldFeatures>::instance().create (lYieldFeaturesKey);
    FacBomManager::addToListAndMap (lSINHKGYieldTimePeriod, 
                                    lSINHKGYieldFeatures);
    FacBomManager::linkWithParent (lSINHKGYieldTimePeriod, 
                                   lSINHKGYieldFeatures);        

    // Generate Segment Features and link them to their YieldRule.
    // Use the same key as previously
    
    // Create the AirlineClassListKey and link it to the YieldFeatures object.
    AirlineClassList& lRAC_SQ_CXAirlineYClassList =
      FacBom<AirlineClassList>::instance().create (lSQ_CXAirlineYClassListKey);
    lRAC_SQ_CXAirlineYClassList.setYield(1200);
    FacBomManager::addToListAndMap (lSINHKGYieldFeatures, 
                                    lRAC_SQ_CXAirlineYClassList);
    FacBomManager::linkWithParent (lSINHKGYieldFeatures, 
                                   lRAC_SQ_CXAirlineYClassList);
    
    AirlineClassList& lRAC_SQ_CXAirlineMClassList =
      FacBom<AirlineClassList>::instance().create (lSQ_CXAirlineMClassListKey);
    lRAC_SQ_CXAirlineMClassList.setYield(850);
    FacBomManager::addToListAndMap (lSINHKGYieldFeatures, 
                                    lRAC_SQ_CXAirlineMClassList);
    FacBomManager::linkWithParent (lSINHKGYieldFeatures, 
                                   lRAC_SQ_CXAirlineMClassList);
    
  }

}

/*!
 */
// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <cassert>
#include <sstream>
// StdAir
#include <stdair/factory/FacBomManager.hpp>
#include <stdair/factory/FacCloneBom.hpp>
#include <stdair/command/CmdCloneBomManager.hpp>
#include <stdair/service/Logger.hpp>
#include <stdair/bom/BomRetriever.hpp>

namespace stdair {  
  
  // ////////////////////////////////////////////////////////////////////
  void CmdCloneBomManager::cloneBomRoot (const BomRoot& iBomRoot,
                                         BomRoot& ioCloneBomRoot) {

    // Check whether there are Inventory objects
    const bool hasInventoryList = BomManager::hasList<Inventory> (iBomRoot);
    if (hasInventoryList == true) {
    
      // Browse the inventories
      const InventoryList_T& lInventoryList =
        BomManager::getList<Inventory> (iBomRoot);
      for (InventoryList_T::const_iterator itInv = lInventoryList.begin();
           itInv != lInventoryList.end(); ++itInv) {
        const Inventory* lInv_ptr = *itInv;
        assert (lInv_ptr != NULL);

        // Clone the current inventory
        Inventory& lCloneInventory = cloneInventory (*lInv_ptr, ioCloneBomRoot);
        FacBomManager::addToListAndMap (ioCloneBomRoot, lCloneInventory);
        FacBomManager::linkWithParent (ioCloneBomRoot, lCloneInventory);
      }
    }

    // Check whether there are Airport Pair objects
    const bool hastAirportPairList = 
      BomManager::hasList<AirportPair> (iBomRoot);
    if (hastAirportPairList == true) {
    
      // Browse the airport pairs
      const AirportPairList_T& lAirportPairList =
        BomManager::getList<AirportPair> (iBomRoot);
      for (AirportPairList_T::const_iterator itAirportPair =
             lAirportPairList.begin();
           itAirportPair != lAirportPairList.end(); ++itAirportPair) {
        const AirportPair* lAirportPair_ptr = *itAirportPair;
        assert (lAirportPair_ptr != NULL);

        // Clone the current airport pair
        AirportPair& lCloneAirportPair = cloneAirportPair (*lAirportPair_ptr);
        FacBomManager::addToListAndMap (ioCloneBomRoot, lCloneAirportPair);
        FacBomManager::linkWithParent (ioCloneBomRoot, lCloneAirportPair);
      }
    }
  }

  // ////////////////////////////////////////////////////////////////////
  Inventory& CmdCloneBomManager::cloneInventory (const Inventory& iInventory,
                                                 BomRoot& ioCloneBomRoot) { 

    Inventory& lCloneInventory = 
      FacCloneBom<Inventory>::instance().clone (iInventory); 

    // Check whether there are FlightDate objects
    const bool hasFlighDateList = BomManager::hasList<FlightDate> (iInventory);
    if (hasFlighDateList == true) {    
      // Browse the flight-dates
      const FlightDateList_T& lFlightDateList =
        BomManager::getList<FlightDate> (iInventory);
      for (FlightDateList_T::const_iterator itFD = lFlightDateList.begin();
           itFD != lFlightDateList.end(); ++itFD) {
        const FlightDate* lFD_ptr = *itFD;
        assert (lFD_ptr != NULL);
      
        // Clone the current flight-date
        FlightDate& lCloneFD = cloneFlightDate (*lFD_ptr);
        FacBomManager::addToListAndMap (lCloneInventory, lCloneFD);
        FacBomManager::linkWithParent (lCloneInventory, lCloneFD);
      }
    }

    // Check if the inventory contains a list of partners
    const bool hasPartnerList = BomManager::hasList<Inventory> (iInventory);
    if (hasPartnerList == true) {
    
      // Browse the partner's inventories
      const InventoryList_T& lPartnerInventoryList =
        BomManager::getList<Inventory> (iInventory);
      
      for (InventoryList_T::const_iterator itInv =
             lPartnerInventoryList.begin();
           itInv != lPartnerInventoryList.end(); ++itInv) {           
        const Inventory* lInv_ptr = *itInv;
        assert (lInv_ptr != NULL);
        
        // Clone the current partnership inventory
        Inventory& lClonePartnerInventory = cloneInventory (*lInv_ptr,
                                                            ioCloneBomRoot);  
        FacBomManager::addToListAndMap (lCloneInventory,
                                        lClonePartnerInventory);
        FacBomManager::linkWithParent (lCloneInventory,
                                       lClonePartnerInventory);   
      }
    }

    // Check whether there are O&D date objects
    const bool hasOnDList = BomManager::hasList<OnDDate> (iInventory);
    if (hasOnDList == true){

      //Browse the O&Ds
      const OnDDateList_T& lOnDDateList =
        BomManager::getList<OnDDate> (iInventory);

      for (OnDDateList_T::const_iterator itOnD = lOnDDateList.begin();
           itOnD != lOnDDateList.end(); ++itOnD) {
        const OnDDate* lOnDDate_ptr = *itOnD;
        assert (lOnDDate_ptr != NULL);

        // Clone the current O&D date
        OnDDate& lCloneOnDDate = cloneOnDDate (*lOnDDate_ptr);
        FacBomManager::addToListAndMap (lCloneInventory, lCloneOnDDate);
        FacBomManager::linkWithParent (lCloneInventory, lCloneOnDDate);
      }
    } 

    // Check whether there are Flight Period objects
    const bool hasFlightPeriodList = 
      BomManager::hasList<FlightPeriod> (iInventory);
    if (hasFlightPeriodList == true) {
    
      // Browse the flight-periods
      const FlightPeriodList_T& lFlightPeriodList =
        BomManager::getList<FlightPeriod> (iInventory);
      for (FlightPeriodList_T::const_iterator itFlightPeriod =
             lFlightPeriodList.begin();
           itFlightPeriod != lFlightPeriodList.end(); ++itFlightPeriod) {
        const FlightPeriod* lFlightPeriod_ptr = *itFlightPeriod;
        assert (lFlightPeriod_ptr != NULL);

        // Clone the current flight period
        FlightPeriod& lCloneFlightPeriod = cloneFlightPeriod (*lFlightPeriod_ptr);
        FacBomManager::addToListAndMap (lCloneInventory, lCloneFlightPeriod);
        FacBomManager::linkWithParent (lCloneInventory, lCloneFlightPeriod);
      }
    }

    // Check whether there is an airline feature object
    const AirlineFeature* lAirlineFeature_ptr =
      BomManager::getObjectPtr<AirlineFeature,Inventory> (iInventory,
                                                          iInventory.getAirlineCode());
    if (lAirlineFeature_ptr != NULL) {
      // Clone the current airline feature object
      AirlineFeature& lCloneAirlineFeature =
        cloneAirlineFeature (*lAirlineFeature_ptr);
      FacBomManager::setAirlineFeature (lCloneInventory, lCloneAirlineFeature);
      FacBomManager::linkWithParent (lCloneInventory, lCloneAirlineFeature);
      // Link the airline feature object with the top of the BOM tree
      FacBomManager::addToListAndMap (ioCloneBomRoot, lCloneAirlineFeature);
    }

    return lCloneInventory;
  }

  // ////////////////////////////////////////////////////////////////////
  AirlineFeature& CmdCloneBomManager::
  cloneAirlineFeature (const AirlineFeature& iAirlineFeature) {   

    AirlineFeature& lCloneAirlineFeature = 
      FacCloneBom<AirlineFeature>::instance().clone (iAirlineFeature);  

    return lCloneAirlineFeature;
  } 
 

  // ////////////////////////////////////////////////////////////////////
  OnDDate& CmdCloneBomManager::cloneOnDDate (const OnDDate& iOnDDate) {   

    OnDDate& lCloneOnDDate = 
      FacCloneBom<OnDDate>::instance().clone (iOnDDate);  

    return lCloneOnDDate;
  } 

  // ////////////////////////////////////////////////////////////////////
  FlightDate& CmdCloneBomManager::
  cloneFlightDate (const FlightDate& iFlightDate) { 

    FlightDate& lCloneFlightDate = 
      FacCloneBom<FlightDate>::instance().clone (iFlightDate);   
    
    // Check whether there are LegDate objects
    const bool hasLegDateList = BomManager::hasList<LegDate> (iFlightDate);
    if (hasLegDateList == true) {

      // Browse the leg-dates
      const LegDateList_T& lLegDateList =
        BomManager::getList<LegDate> (iFlightDate);
      for (LegDateList_T::const_iterator itLD = lLegDateList.begin();
           itLD != lLegDateList.end(); ++itLD) {
        const LegDate* lLD_ptr = *itLD;
        assert (lLD_ptr != NULL); 

        // Clone the current leg-date
        LegDate& lCloneLegDate = cloneLegDate (*lLD_ptr);
        FacBomManager::addToListAndMap (lCloneFlightDate, lCloneLegDate);
        FacBomManager::linkWithParent (lCloneFlightDate, lCloneLegDate);
      }  
    }

    // Check whether there are SegmentDate objects
    const bool hasSegmentDateList = 
      BomManager::hasList<SegmentDate> (iFlightDate);
    if (hasSegmentDateList == true) {
    
      // Browse the segment-dates
      const SegmentDateList_T& lSegmentDateList =
        BomManager::getList<SegmentDate> (iFlightDate);
      for (SegmentDateList_T::const_iterator itSD = lSegmentDateList.begin();
           itSD != lSegmentDateList.end(); ++itSD) {
        const SegmentDate* lSD_ptr = *itSD;
        assert (lSD_ptr != NULL);       

        // Clone the current segment-date
        SegmentDate& lCloneSegmentDate = cloneSegmentDate (*lSD_ptr);
        FacBomManager::addToListAndMap (lCloneFlightDate, lCloneSegmentDate);
        FacBomManager::linkWithParent (lCloneFlightDate, lCloneSegmentDate);

      }
    }
      
    return lCloneFlightDate; 
  } 

  // ////////////////////////////////////////////////////////////////////
  LegDate& CmdCloneBomManager::cloneLegDate (const LegDate& iLegDate) { 

    LegDate& lCloneLegDate = 
      FacCloneBom<LegDate>::instance().clone (iLegDate);

    // Check whether there are LegCabin objects
    const bool hasLegCabinList = BomManager::hasList<LegCabin> (iLegDate);
    if (hasLegCabinList == true) {
      // Browse the leg-cabins
      const LegCabinList_T& lLegCabinList =
        BomManager::getList<LegCabin> (iLegDate);
      for (LegCabinList_T::const_iterator itLC = lLegCabinList.begin();
           itLC != lLegCabinList.end(); ++itLC) {
        const LegCabin* lLC_ptr = *itLC;
        assert (lLC_ptr != NULL);

        // Clone the current leg-cabin  
        LegCabin& lCloneLegCabin = cloneLegCabin (*lLC_ptr);
        FacBomManager::addToListAndMap (lCloneLegDate, lCloneLegCabin);
        FacBomManager::linkWithParent (lCloneLegDate, lCloneLegCabin);
      }
    }

    return lCloneLegDate;
  }

  // ////////////////////////////////////////////////////////////////////
  LegCabin& CmdCloneBomManager::cloneLegCabin (const LegCabin& iLegCabin) { 

    LegCabin& lCloneLegCabin = 
      FacCloneBom<LegCabin>::instance().clone (iLegCabin);

    // Check whether there are Bucket objects
    const bool hasBucketList = BomManager::hasList<Bucket> (iLegCabin);
    if (hasBucketList == true) {
      // Browse the buckets
      const BucketList_T& lBucketList =
        BomManager::getList<Bucket> (iLegCabin);
      for (BucketList_T::const_iterator itBucket = lBucketList.begin();
           itBucket != lBucketList.end(); ++itBucket) {
        const Bucket* lBucket_ptr = *itBucket;
        assert (lBucket_ptr != NULL);

        // Clone the current bucket
        Bucket& lCloneBucket = cloneBucket (*lBucket_ptr);
        FacBomManager::addToListAndMap (lCloneLegCabin, lCloneBucket);
        FacBomManager::linkWithParent (lCloneLegCabin, lCloneBucket);
      }  
    }

    return lCloneLegCabin;
  }

  // ////////////////////////////////////////////////////////////////////
  Bucket& CmdCloneBomManager::cloneBucket (const Bucket& iBucket) { 

    Bucket& lCloneBucket = 
      FacCloneBom<Bucket>::instance().clone (iBucket);  

    return lCloneBucket;
  } 

  // ////////////////////////////////////////////////////////////////////
  SegmentDate& CmdCloneBomManager::
  cloneSegmentDate (const SegmentDate& iSegmentDate) { 

    SegmentDate& lCloneSegmentDate = 
      FacCloneBom<SegmentDate>::instance().clone (iSegmentDate);

    // Check whether there are SegmentCabin objects
    const bool hasSegmentCabinList = 
      BomManager::hasList<SegmentCabin> (iSegmentDate);
    if (hasSegmentCabinList == true) {
      // Browse the segment-cabins
      const SegmentCabinList_T& lSegmentCabinList =
        BomManager::getList<SegmentCabin> (iSegmentDate);
      for (SegmentCabinList_T::const_iterator itSC = lSegmentCabinList.begin();
           itSC != lSegmentCabinList.end(); ++itSC) {
        const SegmentCabin* lSC_ptr = *itSC;
        assert (lSC_ptr != NULL);

        // Clone the current segment-cabin      
        SegmentCabin& lCloneSegmentCabin = cloneSegmentCabin (*lSC_ptr);
        FacBomManager::addToListAndMap (lCloneSegmentDate, lCloneSegmentCabin);
        FacBomManager::linkWithParent (lCloneSegmentDate, lCloneSegmentCabin);
   
        linkBookingClassesWithSegment (lCloneSegmentDate,
                                       lCloneSegmentCabin);

      }
    }
    return lCloneSegmentDate;
  } 

  // ////////////////////////////////////////////////////////////////////
  void CmdCloneBomManager::
  linkBookingClassesWithSegment (SegmentDate& iCloneSegmentDate,
                                 SegmentCabin& iCloneSegmentCabin) {    

    // Browse the fare families to link the booking-classes to the 
    // segment-cabin and to the segment-date 
    const bool hasFareFamilyList = 
      BomManager::hasList<FareFamily> (iCloneSegmentCabin);
    if (hasFareFamilyList == true) {
      const FareFamilyList_T& lCloneFFList =
        BomManager::getList<FareFamily> (iCloneSegmentCabin);
      for (FareFamilyList_T::const_iterator itCloneFF = lCloneFFList.begin();
           itCloneFF != lCloneFFList.end(); ++itCloneFF) {
        const FareFamily* lCloneFF_ptr = *itCloneFF;
        assert (lCloneFF_ptr != NULL);

        // Browse the list of booking classes 
        const bool hasBookingClasslist = 
          BomManager::hasList<BookingClass> (*lCloneFF_ptr);
        if (hasBookingClasslist == true) {
          const BookingClassList_T& lCloneBCList =
            BomManager::getList<BookingClass> (*lCloneFF_ptr);
          for (BookingClassList_T::const_iterator itCloneBC =
                 lCloneBCList.begin();
               itCloneBC != lCloneBCList.end(); ++itCloneBC) {
            const BookingClass* lCloneBC_ptr = *itCloneBC;
            assert (lCloneBC_ptr != NULL);
                
            // Link the booking-class to the segment-cabin
            stdair::FacBomManager::addToListAndMap (iCloneSegmentCabin, 
                                                    *lCloneBC_ptr);

            // Link the booking-class to the segment-date
            stdair::FacBomManager::addToListAndMap (iCloneSegmentDate, 
                                                    *lCloneBC_ptr);
          }
        }
      }
    }
  }

  // ////////////////////////////////////////////////////////////////////
  SegmentCabin& CmdCloneBomManager::
  cloneSegmentCabin (const SegmentCabin& iSegmentCabin) { 

    SegmentCabin& lCloneSegmentCabin = 
      FacCloneBom<SegmentCabin>::instance().clone (iSegmentCabin);

    // Check whether there are fare family objects 
    const bool hasFareFamilyList = 
      BomManager::hasList<FareFamily> (iSegmentCabin);
    if (hasFareFamilyList == true) {
      // Browse the fare families
      const FareFamilyList_T& lFareFamilyList =
        BomManager::getList<FareFamily> (iSegmentCabin);
      for (FareFamilyList_T::const_iterator itFF = lFareFamilyList.begin();
           itFF != lFareFamilyList.end(); ++itFF) {
        const FareFamily* lFF_ptr = *itFF;
        assert (lFF_ptr != NULL);

        // Clone the current fare-family        
        FareFamily& lCloneFareFamily = cloneFareFamily (*lFF_ptr);
        FacBomManager::addToListAndMap (lCloneSegmentCabin, lCloneFareFamily);
        FacBomManager::linkWithParent (lCloneSegmentCabin, lCloneFareFamily);
      }
    }
    
    return lCloneSegmentCabin;
  }

  // ////////////////////////////////////////////////////////////////////
  FareFamily& CmdCloneBomManager::
  cloneFareFamily (const FareFamily& iFareFamily) {
    FareFamily& lCloneFareFamily = 
      FacCloneBom<FareFamily>::instance().clone (iFareFamily);

    // Check whether there are booking classes objects
    const bool hasBookingClassList = 
      BomManager::hasList<BookingClass> (iFareFamily);
    if (hasBookingClassList == true) {
      // Browse the list of booking classes
      const BookingClassList_T& lBookingClassList =
        BomManager::getList<BookingClass> (iFareFamily);
      for (BookingClassList_T::const_iterator itBookingClass =
             lBookingClassList.begin();
           itBookingClass != lBookingClassList.end(); ++itBookingClass) {
        const BookingClass* lBC_ptr = *itBookingClass;
        assert (lBC_ptr != NULL);

        // Clone the current booking class
        BookingClass& lCloneBookingClass = cloneBookingClass (*lBC_ptr);
        FacBomManager::addToListAndMap (lCloneFareFamily, lCloneBookingClass);
        FacBomManager::linkWithParent (lCloneFareFamily, lCloneBookingClass);
      }
    }

    return lCloneFareFamily;
  }

  // ////////////////////////////////////////////////////////////////////
  BookingClass& CmdCloneBomManager::
  cloneBookingClass (const BookingClass& iBookingClass) {
    
    BookingClass& lCloneBookingClass = 
      FacCloneBom<BookingClass>::instance().clone (iBookingClass);

    return lCloneBookingClass;
  }

  // ////////////////////////////////////////////////////////////////////
  AirportPair& CmdCloneBomManager::
  cloneAirportPair (const AirportPair& iAirportPair) {

    AirportPair& lCloneAirportPair = 
      FacCloneBom<AirportPair>::instance().clone (iAirportPair);

    // Check whether there are date-period objects
    const bool hasDatePeriodList = 
      BomManager::hasList<DatePeriod> (iAirportPair);
    if (hasDatePeriodList == true) {
      // Browse the date-periods
      const DatePeriodList_T& lDatePeriodList =
        BomManager::getList<DatePeriod> (iAirportPair);
      for (DatePeriodList_T::const_iterator itDatePeriod =
             lDatePeriodList.begin();
           itDatePeriod != lDatePeriodList.end(); ++itDatePeriod) {
        const DatePeriod* lDatePeriod_ptr = *itDatePeriod;
        assert (lDatePeriod_ptr != NULL);

        // Clone the current date-period        
        DatePeriod& lCloneDatePeriod = cloneDatePeriod (*lDatePeriod_ptr);
        FacBomManager::addToListAndMap (lCloneAirportPair, lCloneDatePeriod);
        FacBomManager::linkWithParent (lCloneAirportPair, lCloneDatePeriod);
      }
    }

    return lCloneAirportPair;
  } 

  // ////////////////////////////////////////////////////////////////////
  DatePeriod& CmdCloneBomManager::
  cloneDatePeriod (const DatePeriod& iDatePeriod) {

    DatePeriod& lCloneDatePeriod = 
      FacCloneBom<DatePeriod>::instance().clone (iDatePeriod);  

    // Check whether there are pos-channel objects
    const bool hasPosChannelList = 
      BomManager::hasList<PosChannel> (iDatePeriod);
    if (hasPosChannelList == true) {
      // Browse the pos-channels
      const PosChannelList_T& lPosChannelList =
        BomManager::getList<PosChannel> (iDatePeriod);
      for (PosChannelList_T::const_iterator itPosChannel =
             lPosChannelList.begin();
           itPosChannel != lPosChannelList.end(); ++itPosChannel) {
        const PosChannel* lPosChannel_ptr = *itPosChannel;
        assert (lPosChannel_ptr != NULL);

        // Clone the current pos-channel        
        PosChannel& lClonePosChannel = clonePosChannel (*lPosChannel_ptr);
        FacBomManager::addToListAndMap (lCloneDatePeriod, lClonePosChannel);
        FacBomManager::linkWithParent (lCloneDatePeriod, lClonePosChannel);
      }
    }

    return lCloneDatePeriod;
  }
  
  
  // ////////////////////////////////////////////////////////////////////
  PosChannel& CmdCloneBomManager::
  clonePosChannel (const PosChannel& iPosChannel) {
    
    PosChannel& lClonePosChannel = 
      FacCloneBom<PosChannel>::instance().clone (iPosChannel);

    // Check whether there are time-period objects
    const bool hasTimePeriodList = 
      BomManager::hasList<TimePeriod> (iPosChannel);
    if (hasTimePeriodList == true) {
      // Browse the time-periods
      const TimePeriodList_T& lTimePeriodList =
        BomManager::getList<TimePeriod> (iPosChannel);
      for (TimePeriodList_T::const_iterator itTimePeriod =
             lTimePeriodList.begin();
           itTimePeriod != lTimePeriodList.end(); ++itTimePeriod) {
        const TimePeriod* lTimePeriod_ptr = *itTimePeriod;
        assert (lTimePeriod_ptr != NULL);

        // Clone the current time-period        
        TimePeriod& lCloneTimePeriod = cloneTimePeriod (*lTimePeriod_ptr);
        FacBomManager::addToListAndMap (lClonePosChannel, lCloneTimePeriod);
        FacBomManager::linkWithParent (lClonePosChannel, lCloneTimePeriod);
      }
    }

    return lClonePosChannel;
  }
  
  // ////////////////////////////////////////////////////////////////////
  TimePeriod& CmdCloneBomManager::
  cloneTimePeriod (const TimePeriod& iTimePeriod) {
    
    TimePeriod& lCloneTimePeriod = 
      FacCloneBom<TimePeriod>::instance().clone (iTimePeriod);

    // Check whether there are fare-feature objects
    const bool hasFareFeaturesList = 
      BomManager::hasList<FareFeatures> (iTimePeriod);
    if (hasFareFeaturesList == true) {
      // Browse the fare-features
      const FareFeaturesList_T& lFareFeaturesList =
        BomManager::getList<FareFeatures> (iTimePeriod);
      for (FareFeaturesList_T::const_iterator itFF = lFareFeaturesList.begin();
           itFF != lFareFeaturesList.end(); ++itFF) {
        const FareFeatures* lFF_ptr = *itFF;
        assert (lFF_ptr != NULL);

        // Clone the current fare-feature       
        FareFeatures& lCloneFareFeatures = 
          cloneFeatures<FareFeatures> (*lFF_ptr);
        FacBomManager::addToListAndMap (lCloneTimePeriod, lCloneFareFeatures);
        FacBomManager::linkWithParent (lCloneTimePeriod, lCloneFareFeatures);
      }
    }

    // Check whether there are yield-feature objects  
    const bool hasYieldFeaturesList = 
      BomManager::hasList<YieldFeatures> (iTimePeriod);
    if (hasYieldFeaturesList == true) {
      // Browse the yield-features
      const YieldFeaturesList_T& lYieldFeaturesList =
        BomManager::getList<YieldFeatures> (iTimePeriod);
      for (YieldFeaturesList_T::const_iterator itYF =
             lYieldFeaturesList.begin();
           itYF != lYieldFeaturesList.end(); ++itYF) {
        const YieldFeatures* lYF_ptr = *itYF;
        assert (lYF_ptr != NULL);

        // Clone the current yield-feature      
        YieldFeatures& lCloneYieldFeatures = 
          cloneFeatures<YieldFeatures> (*lYF_ptr);
        FacBomManager::addToListAndMap (lCloneTimePeriod, lCloneYieldFeatures);
        FacBomManager::linkWithParent (lCloneTimePeriod, lCloneYieldFeatures);
      }
    }

    return lCloneTimePeriod;
  }
  
  // ////////////////////////////////////////////////////////////////////  
  template <typename FEATURE_TYPE>
  FEATURE_TYPE& CmdCloneBomManager::
  cloneFeatures (const FEATURE_TYPE& iFeatures) {

    FEATURE_TYPE& lCloneFeatures = 
      FacCloneBom<FEATURE_TYPE>::instance().clone (iFeatures);

    // Check whether there are airline-class list objects
    const bool hasAirlineClassListList = 
      BomManager::hasList<AirlineClassList> (iFeatures);
    if (hasAirlineClassListList == true) {
      // Browse the airline-class lists
      const AirlineClassListList_T& lAirlineClassList =
        BomManager::getList<AirlineClassList> (iFeatures);
      for (AirlineClassListList_T::const_iterator itACList =
             lAirlineClassList.begin();
           itACList != lAirlineClassList.end(); ++itACList) {
        const AirlineClassList* lACList_ptr = *itACList;
        assert (lACList_ptr != NULL);

        // Clone the current airline-class list 
        AirlineClassList& lCloneAirlineClassList =
          cloneAirlineClassList (*lACList_ptr);
        FacBomManager::addToListAndMap (lCloneFeatures,
                                        lCloneAirlineClassList);
        FacBomManager::linkWithParent (lCloneFeatures,
                                       lCloneAirlineClassList);
      }
    }
    
    return lCloneFeatures;
  }
  
  // ////////////////////////////////////////////////////////////////////
  AirlineClassList& CmdCloneBomManager::
  cloneAirlineClassList (const AirlineClassList& iAirlineClassList) {
    
    AirlineClassList& lCloneAirlineClassList = 
      FacCloneBom<AirlineClassList>::instance().clone (iAirlineClassList);

    return lCloneAirlineClassList;
  }  

  // ////////////////////////////////////////////////////////////////////
  FlightPeriod& CmdCloneBomManager::
  cloneFlightPeriod (const FlightPeriod& iFlightPeriod) {
    
    FlightPeriod& lCloneFlightPeriod = 
      FacCloneBom<FlightPeriod>::instance().clone (iFlightPeriod);

    // Check whether there are airline-class list objects
    const bool hasSegmentPeriodList = 
      BomManager::hasList<SegmentPeriod> (iFlightPeriod);
    if (hasSegmentPeriodList == true) {
      // Browse the airline-class lists
      const SegmentPeriodList_T& lSegmentPeriodList =
        BomManager::getList<SegmentPeriod> (iFlightPeriod);
      for (SegmentPeriodList_T::const_iterator itSegmentPeriod =
             lSegmentPeriodList.begin();
           itSegmentPeriod != lSegmentPeriodList.end(); ++itSegmentPeriod) {
        const SegmentPeriod* lSegmentPeriod_ptr = *itSegmentPeriod;
        assert (lSegmentPeriod_ptr != NULL);

        // Clone the current airline-class list 
        SegmentPeriod& lCloneSegmentPeriod =
          cloneSegmentPeriod (*lSegmentPeriod_ptr);
        FacBomManager::addToListAndMap (lCloneFlightPeriod,
                                        lCloneSegmentPeriod);
        FacBomManager::linkWithParent (lCloneFlightPeriod,
                                       lCloneSegmentPeriod);
      }
    }
    
    return lCloneFlightPeriod;
  } 

  // ////////////////////////////////////////////////////////////////////
  SegmentPeriod& CmdCloneBomManager::
  cloneSegmentPeriod (const SegmentPeriod& iSegmentPeriod) {
    
    SegmentPeriod& lCloneSegmentPeriod = 
      FacCloneBom<SegmentPeriod>::instance().clone (iSegmentPeriod);

    return lCloneSegmentPeriod;
  }

}

/*!