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

stdair/bom/BomDisplay.cpp

Go to the documentation of this file.
00001 
00005 // //////////////////////////////////////////////////////////////////////
00006 // Import section
00007 // //////////////////////////////////////////////////////////////////////
00008 // STL
00009 #include <cassert>
00010 #include <ostream>
00011 // StdAir
00012 #include <stdair/basic/BasConst_BomDisplay.hpp>
00013 #include <stdair/bom/BomManager.hpp>
00014 #include <stdair/bom/BomRoot.hpp>
00015 #include <stdair/bom/Inventory.hpp>
00016 #include <stdair/bom/FlightDate.hpp>
00017 #include <stdair/bom/LegDate.hpp>
00018 #include <stdair/bom/SegmentDate.hpp>
00019 #include <stdair/bom/LegCabin.hpp>
00020 #include <stdair/bom/SegmentCabin.hpp>
00021 #include <stdair/bom/FareFamily.hpp>
00022 #include <stdair/bom/BookingClass.hpp>
00023 #include <stdair/bom/AirportPair.hpp>
00024 #include <stdair/bom/PosChannel.hpp>
00025 #include <stdair/bom/DatePeriod.hpp>
00026 #include <stdair/bom/TimePeriod.hpp>
00027 #include <stdair/bom/FareFeatures.hpp>
00028 #include <stdair/bom/YieldFeatures.hpp>
00029 #include <stdair/bom/AirlineClassList.hpp>
00030 #include <stdair/bom/Bucket.hpp>
00031 #include <stdair/bom/TravelSolutionTypes.hpp>
00032 #include <stdair/bom/TravelSolutionStruct.hpp>
00033 #include <stdair/bom/BomDisplay.hpp>
00034 #include <stdair/bom/OnDDate.hpp>
00035 
00036 namespace stdair {
00037 
00043   struct FlagSaver {
00044   public:
00046     FlagSaver (std::ostream& oStream)
00047       : _oStream (oStream), _streamFlags (oStream.flags()) {
00048     }
00049 
00051     ~FlagSaver() {
00052       // Reset formatting flags of the given output stream
00053       _oStream.flags (_streamFlags);
00054     }
00055     
00056   private:
00058     std::ostream& _oStream;
00060     std::ios::fmtflags _streamFlags;
00061   };
00062 
00063   // ////////////////////////////////////////////////////////////////////
00064   void BomDisplay::list (std::ostream& oStream, const BomRoot& iBomRoot,
00065                          const AirlineCode_T& iAirlineCode,
00066                          const FlightNumber_T& iFlightNumber) {
00067     // Save the formatting flags for the given STL output stream
00068     FlagSaver flagSaver (oStream);
00069 
00070     // Check whether there are Inventory objects
00071     if (BomManager::hasList<Inventory> (iBomRoot) == false) {
00072       return;
00073     }
00074     
00075     // Browse the inventories
00076     unsigned short invIdx = 1;
00077     const InventoryList_T& lInventoryList =
00078       BomManager::getList<Inventory> (iBomRoot);
00079     for (InventoryList_T::const_iterator itInv = lInventoryList.begin();
00080          itInv != lInventoryList.end(); ++itInv, ++invIdx) {
00081       const Inventory* lInv_ptr = *itInv;
00082       assert (lInv_ptr != NULL);
00083 
00084       // Retrieve the inventory key (airline code)
00085       const AirlineCode_T& lAirlineCode = lInv_ptr->getAirlineCode();
00086 
00087       // Display only the requested inventories
00088       if (iAirlineCode == "all" || iAirlineCode == lAirlineCode) {
00089         // Get the list of flight-dates for that inventory
00090         list (oStream, *lInv_ptr, invIdx, iFlightNumber);
00091       }
00092     }
00093   }
00094 
00095   // ////////////////////////////////////////////////////////////////////
00096   void BomDisplay::list (std::ostream& oStream, const Inventory& iInventory,
00097                          const unsigned short iInventoryIndex,
00098                          const FlightNumber_T& iFlightNumber) {
00099     // Save the formatting flags for the given STL output stream
00100     FlagSaver flagSaver (oStream);
00101 
00102     // Check whether there are FlightDate objects
00103     if (BomManager::hasMap<FlightDate> (iInventory) == false) {
00104       return;
00105     }
00106     
00115     //
00116     const AirlineCode_T& lAirlineCode = iInventory.getAirlineCode();
00117     oStream << iInventoryIndex << ". " << lAirlineCode << std::endl;
00118 
00119     // Browse the flight-dates
00120     unsigned short lCurrentFlightNumber = 0;
00121     unsigned short flightNumberIdx = 0;
00122     unsigned short departureDateIdx = 1;
00123     const FlightDateMap_T& lFlightDateList =
00124       BomManager::getMap<FlightDate> (iInventory);
00125     for (FlightDateMap_T::const_iterator itFD = lFlightDateList.begin();
00126          itFD != lFlightDateList.end(); ++itFD, ++departureDateIdx) {
00127       const FlightDate* lFD_ptr = itFD->second;
00128       assert (lFD_ptr != NULL);
00129       
00130       // Retrieve the key of the flight-date
00131       const FlightNumber_T& lFlightNumber = lFD_ptr->getFlightNumber();
00132       const Date_T& lFlightDateDate = lFD_ptr->getDepartureDate();
00133 
00134       // Display only the requested flight number
00135       if (iFlightNumber == 0 || iFlightNumber == lFlightNumber) {
00136         //
00137         if (lCurrentFlightNumber != lFlightNumber) {
00138           lCurrentFlightNumber = lFlightNumber;
00139           ++flightNumberIdx; departureDateIdx = 1;
00140           oStream << "  " << iInventoryIndex << "." << flightNumberIdx << ". "
00141                   << lAirlineCode << lFlightNumber << std::endl;
00142         }
00143       
00144         oStream << "    " << iInventoryIndex << "." << flightNumberIdx
00145                 << "." << departureDateIdx << ". "
00146                 << lAirlineCode << lFlightNumber << " / " << lFlightDateDate
00147                 << std::endl;
00148       }
00149     }   
00150   }
00151 
00152   // ////////////////////////////////////////////////////////////////////
00153   void BomDisplay::listAirportPairDateRange (std::ostream& oStream,
00154                                              const BomRoot& iBomRoot) {
00155     // Save the formatting flags for the given STL output stream
00156     FlagSaver flagSaver (oStream);
00157 
00158     // Check whether there are AirportPair objects
00159     if (BomManager::hasList<AirportPair> (iBomRoot) == false) {
00160       return;
00161     }
00162 
00163     const AirportPairList_T& lAirportPairList =
00164       BomManager::getList<AirportPair> (iBomRoot);
00165     for (AirportPairList_T::const_iterator itAir = lAirportPairList.begin();
00166          itAir != lAirportPairList.end(); ++itAir ) {
00167       const AirportPair* lAir_ptr = *itAir;      
00168       assert (lAir_ptr != NULL);
00169 
00170       // Check whether there are date-period objects
00171       assert (BomManager::hasList<DatePeriod> (*lAir_ptr) == true);
00172 
00173       // Browse the date-period objects
00174       const DatePeriodList_T& lDatePeriodList =
00175         BomManager::getList<DatePeriod> (*lAir_ptr);
00176       
00177       for (DatePeriodList_T::const_iterator itDP = lDatePeriodList.begin();
00178            itDP != lDatePeriodList.end(); ++itDP) {
00179         const DatePeriod* lDP_ptr = *itDP;
00180         assert (lDP_ptr != NULL);
00181       
00182         // Display the date-period object
00183         oStream << lAir_ptr->describeKey()
00184                 <<" / " << lDP_ptr->describeKey() << std::endl;
00185       }  
00186 
00187     }   
00188   }
00189   
00190   // ////////////////////////////////////////////////////////////////////
00191   void BomDisplay::csvDisplay (std::ostream& oStream,
00192                                const BomRoot& iBomRoot) {
00193     // Save the formatting flags for the given STL output stream
00194     FlagSaver flagSaver (oStream);
00195 
00199     oStream << std::endl;
00200     oStream << "==============================================================="
00201             << std::endl;
00202     oStream << "BomRoot: " << iBomRoot.describeKey() << std::endl;
00203     oStream << "==============================================================="
00204             << std::endl;
00205 
00206     // Check whether there are Inventory objects
00207     if (BomManager::hasList<Inventory> (iBomRoot) == false) {
00208       return;
00209     }
00210     
00211     // Browse the inventories
00212     const InventoryList_T& lInventoryList =
00213       BomManager::getList<Inventory> (iBomRoot);
00214     for (InventoryList_T::const_iterator itInv = lInventoryList.begin();
00215          itInv != lInventoryList.end(); ++itInv) {
00216       const Inventory* lInv_ptr = *itInv;
00217       assert (lInv_ptr != NULL);
00218 
00219       // Display the inventory
00220       csvDisplay (oStream, *lInv_ptr);
00221     }
00222   }
00223 
00224   // ////////////////////////////////////////////////////////////////////
00225   void BomDisplay::csvDisplay (std::ostream& oStream,
00226                                const Inventory& iInventory) {
00227     // Save the formatting flags for the given STL output stream
00228     FlagSaver flagSaver (oStream);
00229 
00233     oStream << "+++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
00234     oStream << "Inventory: " << iInventory.describeKey() << std::endl;
00235     oStream << "+++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
00236 
00237     // Check whether there are FlightDate objects
00238     if (BomManager::hasList<FlightDate> (iInventory) == false) {
00239       return;
00240     }
00241     
00242     // Browse the flight-dates
00243     const FlightDateList_T& lFlightDateList =
00244       BomManager::getList<FlightDate> (iInventory);
00245     for (FlightDateList_T::const_iterator itFD = lFlightDateList.begin();
00246          itFD != lFlightDateList.end(); ++itFD) {
00247       const FlightDate* lFD_ptr = *itFD;
00248       assert (lFD_ptr != NULL);
00249       
00250       // Display the flight-date
00251       csvDisplay (oStream, *lFD_ptr);
00252     }
00253 
00254     // Check if the inventory contains a list of partners
00255 
00256     if (BomManager::hasList<Inventory> (iInventory)){
00257     
00258       // Browse the partner's inventories
00259       const InventoryList_T& lPartnerInventoryList =
00260         BomManager::getList<Inventory> (iInventory);
00261       
00262       for (InventoryList_T::const_iterator itInv = lPartnerInventoryList.begin();
00263            itInv != lPartnerInventoryList.end(); ++itInv) {           
00264       
00265         oStream << "-------------------------------------------------" << std::endl;
00266         oStream << "Partner inventory:" << std::endl;
00267         oStream << "-------------------------------------------------" << std::endl;
00268         const Inventory* lInv_ptr = *itInv;
00269         assert (lInv_ptr != NULL);
00270       
00271         // Display the inventory
00272         csvDisplay (oStream, *lInv_ptr);      
00273       }
00274       oStream << "******************************************" << std::endl;
00275       oStream << std::endl;
00276     }
00277 
00278     // Check if the inventory contains a list of O&D dates
00279 
00280     if (BomManager::hasList<OnDDate> (iInventory)){
00281 
00282       //Browse the O&Ds
00283       const OnDDateList_T& lOnDDateList =
00284         BomManager::getList<OnDDate> (iInventory);
00285 
00286       for (OnDDateList_T::const_iterator itOnD = lOnDDateList.begin();
00287            itOnD != lOnDDateList.end(); ++itOnD) {
00288         oStream << "******************************************" << std::endl;
00289         oStream << "O&D-Date:" << std::endl;
00290         oStream << "----------" << std::endl;
00291         oStream << "Airline, Date, Origin-Destination, Segments, " << std::endl;
00292        
00293         const OnDDate* lOnDDate_ptr = *itOnD;
00294         assert (lOnDDate_ptr != NULL);
00295 
00296         // Display the O&D date
00297         csvDisplay (oStream, *lOnDDate_ptr);
00298       }
00299       oStream << "******************************************" << std::endl;
00300     }
00301   }
00302 
00303   // ////////////////////////////////////////////////////////////////////
00304   void BomDisplay::csvDisplay (std::ostream& oStream,
00305                                const OnDDate& iOnDDate) {
00306     // Save the formatting flags for the given STL output stream
00307     FlagSaver flagSaver (oStream);
00308 
00312     const AirlineCode_T& lAirlineCode = iOnDDate.getAirlineCode();
00313     const Date_T& lDate = iOnDDate.getDate();
00314     const AirportCode_T& lOrigin = iOnDDate.getOrigin();
00315     const AirportCode_T& lDestination = iOnDDate.getDestination();
00316     
00317     oStream << lAirlineCode <<", " << lDate << ", "<< lOrigin << "-"
00318             << lDestination << ", " << iOnDDate.describeKey() << ", "
00319             << std::endl;
00320         
00321     const StringDemandStructMap_T& lDemandInfoMap =
00322       iOnDDate.getDemandInfoMap();
00323 
00324     // Check if the map contains information.
00325     const bool isInfoMapEmpty = lDemandInfoMap.empty();
00326     if (isInfoMapEmpty) {
00327       return;
00328     }
00329     assert (lDemandInfoMap.empty() ==false);
00330     
00331     oStream << "----------" << std::endl;        
00332     oStream << "Cabin-Class path, Demand mean, Demand std dev, Yield, "
00333             << std::endl;
00334     
00335     for (StringDemandStructMap_T::const_iterator itDI = lDemandInfoMap.begin();
00336          itDI != lDemandInfoMap.end(); ++itDI) {
00337       
00338       const std::string& lCabinClassPath = itDI->first;
00339       const YieldDemandPair_T lYieldDemandPair =
00340         itDI->second;
00341       const Yield_T lYield = lYieldDemandPair.first;
00342       const MeanStdDevPair_T lMeanStdDevPair =
00343         lYieldDemandPair.second;
00344       const MeanValue_T lDemandMean = lMeanStdDevPair.first;
00345       const StdDevValue_T lDemandStdDev = lMeanStdDevPair.second;
00346 
00347       oStream << lCabinClassPath << ", "
00348               << lDemandMean << ", "
00349               << lDemandStdDev << ", "
00350               << lYield << ", "
00351               << std::endl;
00352     }
00353      
00354   }
00355     
00356   // ////////////////////////////////////////////////////////////////////
00357   void BomDisplay::csvDisplay (std::ostream& oStream,
00358                                const FlightDate& iFlightDate) {
00359     // Save the formatting flags for the given STL output stream
00360     FlagSaver flagSaver (oStream);
00361 
00365     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00366     oStream << "******************************************" << std::endl;
00367     oStream << "FlightDate: " << lAirlineCode << iFlightDate.describeKey()
00368             << std::endl;
00369     oStream << "******************************************" << std::endl;
00370 
00371     //
00372     csvSegmentDateDisplay (oStream, iFlightDate);
00373     //
00374     csvLegDateDisplay (oStream, iFlightDate);
00375 
00376     //
00377     csvLegCabinDisplay (oStream, iFlightDate);
00378 
00379     //
00380     csvBucketDisplay (oStream, iFlightDate);
00381 
00382     //
00383     csvFareFamilyDisplay (oStream, iFlightDate);
00384 
00385     //
00386     csvBookingClassDisplay (oStream, iFlightDate);
00387   }
00388     
00389   // ////////////////////////////////////////////////////////////////////
00390   void BomDisplay::csvLegDateDisplay (std::ostream& oStream,
00391                                       const FlightDate& iFlightDate) {
00392     // Save the formatting flags for the given STL output stream
00393     FlagSaver flagSaver (oStream);
00394 
00400     oStream << "******************************************" << std::endl;
00401     oStream << "Leg-Dates:" << std::endl
00402             << "----------" << std::endl;
00403     oStream << "Flight, Leg, BoardDate, BoardTime, "
00404             << "OffDate, OffTime, Date Offset, Time Offset, Elapsed, "
00405             << "Distance, Capacity, " << std::endl;
00406 
00407     // Retrieve the key of the flight-date
00408     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00409     const FlightNumber_T& lFlightNumber = iFlightDate.getFlightNumber();
00410     const Date_T& lFlightDateDate = iFlightDate.getDepartureDate();
00411 
00412     // Check whether there are LegDate objects
00413     if (BomManager::hasList<LegDate> (iFlightDate) == false) {
00414       return;
00415     }
00416     
00417     // Browse the leg-dates
00418     const LegDateList_T& lLegDateList =
00419       BomManager::getList<LegDate> (iFlightDate);
00420     for (LegDateList_T::const_iterator itLD = lLegDateList.begin();
00421          itLD != lLegDateList.end(); ++itLD) {
00422       const LegDate* lLD_ptr = *itLD;
00423       assert (lLD_ptr != NULL);
00424       
00425       oStream << lAirlineCode << lFlightNumber << " "
00426               << lFlightDateDate << ", ";
00427 
00428       oStream << lLD_ptr->getBoardingPoint() << "-"
00429               << lLD_ptr->getOffPoint() << ", "
00430               << lLD_ptr->getBoardingDate() << ", "
00431               << lLD_ptr->getBoardingTime() << ", "
00432               << lLD_ptr->getOffDate() << ", "
00433               << lLD_ptr->getOffTime() << ", "
00434               << lLD_ptr->getElapsedTime() << ", "
00435               << lLD_ptr->getDateOffset().days() << ", "
00436               << lLD_ptr->getTimeOffset() << ", "
00437               << lLD_ptr->getDistance() << ", "
00438               << lLD_ptr->getCapacity() << ", " << std::endl;
00439     }
00440     oStream << "******************************************" << std::endl;
00441   }
00442     
00443   // ////////////////////////////////////////////////////////////////////
00444   void BomDisplay::csvSegmentDateDisplay (std::ostream& oStream,
00445                                           const FlightDate& iFlightDate) {
00446     // Save the formatting flags for the given STL output stream
00447     FlagSaver flagSaver (oStream);
00448 
00452     oStream << "******************************************" << std::endl;
00453     oStream << "SegmentDates:" << std::endl
00454             << "----------" << std::endl;
00455     oStream << "Flight, Segment, Date"
00456             << std::endl;
00457 
00458     // Retrieve the key of the flight-date
00459     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00460     const FlightNumber_T& lFlightNumber = iFlightDate.getFlightNumber();
00461     const Date_T& lFlightDateDate = iFlightDate.getDepartureDate();
00462 
00463     // Check whether there are SegmentDate objects
00464     if (BomManager::hasList<SegmentDate> (iFlightDate) == false) {
00465       return;
00466     }
00467     
00468     // Browse the segment-dates
00469     const SegmentDateList_T& lSegmentDateList =
00470       BomManager::getList<SegmentDate> (iFlightDate);
00471     for (SegmentDateList_T::const_iterator itSD = lSegmentDateList.begin();
00472          itSD != lSegmentDateList.end(); ++itSD) {
00473       const SegmentDate* lSD_ptr = *itSD;
00474       assert (lSD_ptr != NULL);
00475       
00476       // Retrieve the key of the segment-date, as well as its dates
00477       const Date_T& lSegmentDateDate = lSD_ptr->getBoardingDate();
00478       const AirportCode_T& lBoardPoint = lSD_ptr->getBoardingPoint();
00479       const AirportCode_T& lOffPoint = lSD_ptr->getOffPoint();
00480       oStream << lAirlineCode << lFlightNumber << " " << lFlightDateDate << ", "
00481               << lBoardPoint << "-" << lOffPoint << ", " << lSegmentDateDate << std::endl;
00482 
00483       // Check if the current segment has corresponding marketing segments. 
00484       const bool hasMarketingSDList = BomManager::hasList<SegmentDate>(*lSD_ptr);
00485       if (hasMarketingSDList == true) {
00486         //
00487         const SegmentDateList_T& lMarketingSDList = BomManager::getList<SegmentDate>(*lSD_ptr);
00488           
00489         oStream << " *** Marketed by ";
00490         for (SegmentDateList_T::const_iterator itMarketingSD = lMarketingSDList.begin();
00491              itMarketingSD != lMarketingSDList.end(); ++itMarketingSD) {
00492           SegmentDate* lMarketingSD_ptr = *itMarketingSD;
00493           FlightDate* lMarketingFD_ptr = BomManager::getParentPtr<FlightDate>(*lMarketingSD_ptr);
00494           Inventory* lMarketingInv_ptr = BomManager::getParentPtr<Inventory>(*lMarketingFD_ptr);
00495           oStream << lMarketingInv_ptr->toString() << lMarketingFD_ptr->toString() <<" * ";
00496         }
00497       }
00498 
00499       // Check if the current segment is operated by another segment date. 
00500       const SegmentDate* lOperatingSD_ptr = lSD_ptr->getOperatingSegmentDate ();
00501       if (lOperatingSD_ptr != NULL) {
00502 
00503         const FlightDate* lOperatingFD_ptr = BomManager::getParentPtr<FlightDate>(*lOperatingSD_ptr);
00504         const Inventory* lOperatingInv_ptr = BomManager::getParentPtr<Inventory>(*lOperatingFD_ptr);
00505         oStream << " *** Operated by " << lOperatingInv_ptr->toString()
00506                 << lOperatingFD_ptr->toString() << std::endl;
00507       }
00508       
00509       oStream << std::endl;
00510     }
00511   }
00512 
00513   // ////////////////////////////////////////////////////////////////////
00514   void BomDisplay::csvLegCabinDisplay (std::ostream& oStream,
00515                                        const FlightDate& iFlightDate) {
00516     // Save the formatting flags for the given STL output stream
00517     FlagSaver flagSaver (oStream);
00518 
00522     oStream << "******************************************" << std::endl;
00523     oStream << "LegCabins:" << std::endl
00524             << "----------" << std::endl;
00525     oStream << "Flight, Leg, Cabin, "
00526             << "OffedCAP, PhyCAP, RgdADJ, AU, UPR, SS, Staff, WL, Group, "
00527             << "CommSpace, AvPool, Avl, NAV, GAV, ACP, ETB, BidPrice, "
00528             << std::endl;
00529     
00530     // Retrieve the key of the flight-date
00531     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00532     const FlightNumber_T& lFlightNumber = iFlightDate.getFlightNumber();
00533     const Date_T& lFlightDateDate = iFlightDate.getDepartureDate();
00534     
00535     // Check whether there are LegDate objects
00536     if (BomManager::hasList<LegDate> (iFlightDate) == false) {
00537       return;
00538     }
00539     
00540     // Browse the leg-dates
00541     const LegDateList_T& lLegDateList =
00542       BomManager::getList<LegDate> (iFlightDate);
00543     for (LegDateList_T::const_iterator itLD = lLegDateList.begin();
00544          itLD != lLegDateList.end(); ++itLD) {
00545       const LegDate* lLD_ptr = *itLD;
00546       assert (lLD_ptr != NULL);
00547 
00548       // Retrieve the key of the leg-date, as well as its off point
00549       const Date_T& lLegDateDate = lLD_ptr->getBoardingDate();
00550       const AirportCode_T& lBoardPoint = lLD_ptr->getBoardingPoint();
00551       const AirportCode_T& lOffPoint = lLD_ptr->getOffPoint();
00552 
00553       // Browse the leg-cabins
00554       const LegCabinList_T& lLegCabinList =
00555         BomManager::getList<LegCabin> (*lLD_ptr);
00556       for (LegCabinList_T::const_iterator itLC = lLegCabinList.begin();
00557            itLC != lLegCabinList.end(); ++itLC) {
00558         const LegCabin* lLC_ptr = *itLC;
00559         assert (lLC_ptr != NULL);
00560       
00561         oStream << lAirlineCode << lFlightNumber << " "
00562                 << lFlightDateDate << ", ";
00563 
00564         oStream << lBoardPoint << "-" << lOffPoint
00565                 << " " << lLegDateDate << ", ";
00566 
00567         oStream << lLC_ptr->getCabinCode() << ", ";
00568 
00569         oStream << lLC_ptr->getOfferedCapacity() << ", "
00570                 << lLC_ptr->getPhysicalCapacity() << ", "
00571                 << lLC_ptr->getRegradeAdjustment() << ", "
00572                 << lLC_ptr->getAuthorizationLevel() << ", "
00573                 << lLC_ptr->getUPR() << ", "
00574                 << lLC_ptr->getSoldSeat() << ", "
00575                 << lLC_ptr->getStaffNbOfSeats() << ", "
00576                 << lLC_ptr->getWLNbOfSeats() << ", "
00577                 << lLC_ptr->getGroupNbOfSeats() << ", "
00578                 << lLC_ptr->getCommittedSpace() << ", "
00579                 << lLC_ptr->getAvailabilityPool() << ", "
00580                 << lLC_ptr->getAvailability() << ", "
00581                 << lLC_ptr->getNetAvailability() << ", "
00582                 << lLC_ptr->getGrossAvailability() << ", "
00583                 << lLC_ptr->getAvgCancellationPercentage() << ", "
00584                 << lLC_ptr->getETB() << ", "
00585                 << lLC_ptr->getCurrentBidPrice() << ", "
00586                 << std::endl;
00587       }
00588     }
00589     oStream << "******************************************" << std::endl;
00590   }
00591     
00592   // ////////////////////////////////////////////////////////////////////
00593   void BomDisplay::csvSegmentCabinDisplay (std::ostream& oStream,
00594                                            const FlightDate& iFlightDate) {
00595     // Save the formatting flags for the given STL output stream
00596     FlagSaver flagSaver (oStream);
00597 
00601   }
00602 
00603   // ////////////////////////////////////////////////////////////////////
00604   void BomDisplay::csvFareFamilyDisplay (std::ostream& oStream,
00605                                          const FlightDate& iFlightDate) {
00606     // Save the formatting flags for the given STL output stream
00607     FlagSaver flagSaver (oStream);
00608 
00613     oStream << "******************************************" << std::endl;
00614     oStream << "SegmentCabins:" << std::endl
00615             << "--------------" << std::endl;
00616     oStream << "Flight, Segment, Cabin, FF, Bkgs, MIN, UPR, "
00617             << "CommSpace, AvPool, BP, " << std::endl;
00618     
00619     // Retrieve the key of the flight-date
00620     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00621     const FlightNumber_T& lFlightNumber = iFlightDate.getFlightNumber();
00622     const Date_T& lFlightDateDate = iFlightDate.getDepartureDate();
00623 
00624     // Check whether there are SegmentDate objects
00625     if (BomManager::hasList<SegmentDate> (iFlightDate) == false) {
00626       return;
00627     }
00628     
00629     // Browse the segment-dates
00630     const SegmentDateList_T& lSegmentDateList =
00631       BomManager::getList<SegmentDate> (iFlightDate);
00632     for (SegmentDateList_T::const_iterator itSD = lSegmentDateList.begin();
00633          itSD != lSegmentDateList.end(); ++itSD) {
00634       const SegmentDate* lSD_ptr = *itSD;
00635       assert (lSD_ptr != NULL);
00636       
00637       // Retrieve the key of the segment-date, as well as its dates
00638       const Date_T& lSegmentDateDate = lSD_ptr->getBoardingDate();
00639       const AirportCode_T& lBoardPoint = lSD_ptr->getBoardingPoint();
00640       const AirportCode_T& lOffPoint = lSD_ptr->getOffPoint();
00641       
00642       // Browse the segment-cabins
00643       const SegmentCabinList_T& lSegmentCabinList =
00644         BomManager::getList<SegmentCabin> (*lSD_ptr);
00645       for (SegmentCabinList_T::const_iterator itSC = lSegmentCabinList.begin();
00646            itSC != lSegmentCabinList.end(); ++itSC) {
00647         const SegmentCabin* lSC_ptr = *itSC;
00648         assert (lSC_ptr != NULL);
00649         
00650         // Retrieve the key of the segment-cabin
00651         const CabinCode_T& lCabinCode = lSC_ptr->getCabinCode();
00652 
00653         // Check whether there are fare family objects
00654         if (BomManager::hasList<FareFamily> (*lSC_ptr) == false) {
00655           continue;
00656         }
00657     
00658         // Browse the fare families
00659         const FareFamilyList_T& lFareFamilyList =
00660           BomManager::getList<FareFamily> (*lSC_ptr);
00661         for (FareFamilyList_T::const_iterator itFF = lFareFamilyList.begin();
00662              itFF != lFareFamilyList.end(); ++itFF) {
00663           const FareFamily* lFF_ptr = *itFF;
00664           assert (lFF_ptr != NULL);
00665 
00666           oStream << lAirlineCode << lFlightNumber << " "
00667                   << lFlightDateDate << ", ";
00668 
00669           oStream << lBoardPoint << "-" << lOffPoint << " "
00670                   << lSegmentDateDate << ", ";
00671 
00672           oStream << lCabinCode << ", " << lFF_ptr->getFamilyCode() << ", ";
00673 
00674           oStream << lSC_ptr->getBookingCounter() << ", "
00675                   << lSC_ptr->getMIN() << ", "
00676                   << lSC_ptr->getUPR() << ", "
00677                   << lSC_ptr->getCommittedSpace() << ", "
00678                   << lSC_ptr->getAvailabilityPool() << ", "
00679                   << lSC_ptr->getCurrentBidPrice() << ", "
00680                   << std::endl;
00681         }
00682       }
00683     }
00684     oStream << "******************************************" << std::endl;
00685   }
00686 
00687   // ////////////////////////////////////////////////////////////////////
00688   void BomDisplay::csvBucketDisplay (std::ostream& oStream,
00689                                      const FlightDate& iFlightDate) {
00690     // Save the formatting flags for the given STL output stream
00691     FlagSaver flagSaver (oStream);
00692 
00696     oStream << "******************************************" << std::endl;
00697     oStream << "Buckets:" << std::endl
00698             << "--------" << std::endl;
00699     oStream << "Flight, Leg, Cabin, Yield, AU/SI, SS, AV, "
00700             << std::endl;
00701 
00702     // Retrieve the key of the flight-date
00703     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00704     const FlightNumber_T& lFlightNumber = iFlightDate.getFlightNumber();
00705     const Date_T& lFlightDateDate = iFlightDate.getDepartureDate();
00706 
00707     // Check whether there are LegDate objects
00708     if (BomManager::hasList<LegDate> (iFlightDate) == false) {
00709       return;
00710     }
00711     
00712     // Browse the leg-dates
00713     const LegDateList_T& lLegDateList =
00714       BomManager::getList<LegDate> (iFlightDate);
00715     for (LegDateList_T::const_iterator itLD = lLegDateList.begin();
00716          itLD != lLegDateList.end(); ++itLD) {
00717       const LegDate* lLD_ptr = *itLD;
00718       assert (lLD_ptr != NULL);
00719       
00720       // Retrieve the key of the leg-date, as well as its off point
00721       const Date_T& lLegDateDate = lLD_ptr->getBoardingDate();
00722       const AirportCode_T& lBoardPoint = lLD_ptr->getBoardingPoint();
00723       const AirportCode_T& lOffPoint = lLD_ptr->getOffPoint();
00724 
00725       // Browse the leg-cabins
00726       const LegCabinList_T& lLegCabinList =
00727         BomManager::getList<LegCabin> (*lLD_ptr);
00728       for (LegCabinList_T::const_iterator itLC = lLegCabinList.begin();
00729            itLC != lLegCabinList.end(); ++itLC) {
00730         const LegCabin* lLC_ptr = *itLC;
00731         assert (lLC_ptr != NULL);
00732 
00733         // Check whether there are bucket objects
00734         if (BomManager::hasList<Bucket> (*lLC_ptr) == false) {
00735           continue;
00736         }
00737 
00738         // Retrieve the key of the leg-cabin
00739         const CabinCode_T& lCabinCode = lLC_ptr->getCabinCode();      
00740 
00741         // Browse the buckets
00742         const BucketList_T& lBucketList = BomManager::getList<Bucket> (*lLC_ptr);
00743         for (BucketList_T::const_iterator itBuck = lBucketList.begin();
00744              itBuck != lBucketList.end(); ++itBuck) {
00745           const Bucket* lBucket_ptr = *itBuck;
00746           assert (lBucket_ptr != NULL);
00747 
00748           oStream << lAirlineCode << lFlightNumber << " "
00749                   << lFlightDateDate << ", ";
00750 
00751           oStream << lBoardPoint << "-" << lOffPoint << " "
00752                   << lLegDateDate << ", " << lCabinCode << ", ";
00753 
00754           oStream << lBucket_ptr->getYieldRangeUpperValue() << ", "
00755                   << lBucket_ptr->getSeatIndex() << ", "
00756                   << lBucket_ptr->getSoldSeats() << ", "
00757                   << lBucket_ptr->getAvailability() << ", ";
00758           oStream << std::endl;
00759         }
00760       }
00761     }
00762     oStream << "******************************************" << std::endl;
00763   }
00764     
00765   // ////////////////////////////////////////////////////////////////////
00766   void BomDisplay::csvBookingClassDisplay (std::ostream& oStream,
00767                                            const BookingClass& iBookingClass,
00768                                            const std::string& iLeadingString) {
00769     // Save the formatting flags for the given STL output stream
00770     FlagSaver flagSaver (oStream);
00771 
00778     oStream << iLeadingString << iBookingClass.getClassCode();
00779 
00780     if (iBookingClass.getSubclassCode() == 0) {
00781       oStream << ", ";
00782     } else {
00783       oStream << iBookingClass.getSubclassCode() << ", ";
00784     }
00785     oStream << iBookingClass.getAuthorizationLevel() << " ("
00786             << iBookingClass.getProtection() << "), "
00787             << iBookingClass.getNegotiatedSpace() << ", "
00788             << iBookingClass.getNoShowPercentage() << ", "
00789             << iBookingClass.getCancellationPercentage() << ", "
00790             << iBookingClass.getNbOfBookings() << ", "
00791             << iBookingClass.getNbOfGroupBookings() << " ("
00792             << iBookingClass.getNbOfPendingGroupBookings() << "), "
00793             << iBookingClass.getNbOfStaffBookings() << ", "
00794             << iBookingClass.getNbOfWLBookings() << ", "
00795             << iBookingClass.getETB() << ", "
00796             << iBookingClass.getNetClassAvailability() << ", "
00797             << iBookingClass.getNetRevenueAvailability() << ", "
00798             << iBookingClass.getSegmentAvailability() << ", "
00799             << std::endl;
00800   }
00801 
00802   // ////////////////////////////////////////////////////////////////////
00803   void BomDisplay::csvBookingClassDisplay (std::ostream& oStream,
00804                                            const FlightDate& iFlightDate) {
00805     // Save the formatting flags for the given STL output stream
00806     FlagSaver flagSaver (oStream);
00807 
00808     // Headers
00809     oStream << "******************************************" << std::endl;
00810     oStream << "Subclasses:" << std::endl
00811             << "-----------" << std::endl;
00812     oStream << "Flight, Segment, Cabin, FF, Subclass, MIN/AU (Prot), "
00813             << "Nego, NS%, OB%, "
00814             << "Bkgs, GrpBks (pdg), StfBkgs, WLBkgs, ETB, "
00815             << "ClassAvl, RevAvl, SegAvl, "
00816             << std::endl;
00817 
00818     // Retrieve the key of the flight-date
00819     const AirlineCode_T& lAirlineCode = iFlightDate.getAirlineCode();
00820     const FlightNumber_T& lFlightNumber = iFlightDate.getFlightNumber();
00821     const Date_T& lFlightDateDate = iFlightDate.getDepartureDate();
00822     
00823     // Check whether there are SegmentDate objects
00824     if (BomManager::hasList<SegmentDate> (iFlightDate) == false) {
00825       return;
00826     }
00827     
00828     // Browse the segment-dates
00829     const SegmentDateList_T& lSegmentDateList =
00830       BomManager::getList<SegmentDate> (iFlightDate);
00831     for (SegmentDateList_T::const_iterator itSD = lSegmentDateList.begin();
00832          itSD != lSegmentDateList.end(); ++itSD) {
00833       const SegmentDate* lSD_ptr = *itSD;
00834       assert (lSD_ptr != NULL);
00835       
00836       // Retrieve the key of the segment-date, as well as its dates
00837       const Date_T& lSegmentDateDate = lSD_ptr->getBoardingDate();
00838       const AirportCode_T& lBoardPoint = lSD_ptr->getBoardingPoint();
00839       const AirportCode_T& lOffPoint = lSD_ptr->getOffPoint();
00840       
00841       // Browse the segment-cabins
00842       const SegmentCabinList_T& lSegmentCabinList =
00843         BomManager::getList<SegmentCabin> (*lSD_ptr);
00844       for (SegmentCabinList_T::const_iterator itSC = lSegmentCabinList.begin();
00845            itSC != lSegmentCabinList.end(); ++itSC) {
00846         const SegmentCabin* lSC_ptr = *itSC;
00847         assert (lSC_ptr != NULL);
00848         
00849         // Retrieve the key of the segment-cabin
00850         const CabinCode_T& lCabinCode = lSC_ptr->getCabinCode();
00851         
00852         // Build the leading string to be displayed
00853         std::ostringstream oSCLeadingStr;
00854         oSCLeadingStr << lAirlineCode << lFlightNumber << " "
00855                       << lFlightDateDate << ", "
00856                       << lBoardPoint << "-" << lOffPoint << " "
00857                       << lSegmentDateDate << ", "
00858                       << lCabinCode << ", ";
00859 
00860         // Default Fare Family code, when there are no FF
00861         FamilyCode_T lFamilyCode ("NoFF");
00862 
00863         // Check whether there are FareFamily objects
00864         if (BomManager::hasList<FareFamily> (*lSC_ptr) == true) {
00865 
00866           // Browse the fare families
00867           const FareFamilyList_T& lFareFamilyList =
00868             BomManager::getList<FareFamily> (*lSC_ptr);
00869           for (FareFamilyList_T::const_iterator itFF = lFareFamilyList.begin();
00870                itFF != lFareFamilyList.end(); ++itFF) {
00871             const FareFamily* lFF_ptr = *itFF;
00872             assert (lFF_ptr != NULL);
00873 
00874             // Retrieve the key of the segment-cabin
00875             lFamilyCode = lFF_ptr->getFamilyCode();
00876 
00877             // Complete the leading string to be displayed
00878             std::ostringstream oFFLeadingStr;
00879             oFFLeadingStr << oSCLeadingStr.str() << lFamilyCode << ", ";
00880 
00881             // Browse the booking-classes
00882             const BookingClassList_T& lBookingClassList =
00883               BomManager::getList<BookingClass> (*lFF_ptr);
00884             for (BookingClassList_T::const_iterator itBC =
00885                    lBookingClassList.begin();
00886                  itBC != lBookingClassList.end(); ++itBC) {
00887               const BookingClass* lBC_ptr = *itBC;
00888               assert (lBC_ptr != NULL);
00889 
00890               //
00891               csvBookingClassDisplay (oStream, *lBC_ptr, oFFLeadingStr.str());
00892             }
00893           }
00894 
00895           // Go on to the next segment-cabin
00896           continue;
00897         }
00898         assert (BomManager::hasList<FareFamily> (*lSC_ptr) == false);
00899 
00900         // The fare family code is a fake one ('NoFF'), and therefore
00901         // does not vary
00902         std::ostringstream oFFLeadingStr;
00903         oFFLeadingStr << oSCLeadingStr.str() << lFamilyCode << ", ";
00904 
00905         // Browse the booking-classes, directly from the segment-cabin object
00906         const BookingClassList_T& lBookingClassList =
00907           BomManager::getList<BookingClass> (*lSC_ptr);
00908         for (BookingClassList_T::const_iterator itBC =
00909                lBookingClassList.begin();
00910              itBC != lBookingClassList.end(); ++itBC) {
00911           const BookingClass* lBC_ptr = *itBC;
00912           assert (lBC_ptr != NULL);
00913 
00914           //
00915           csvBookingClassDisplay (oStream, *lBC_ptr, oFFLeadingStr.str());
00916         }
00917       }
00918     }
00919     oStream << "******************************************" << std::endl;
00920   }
00921 
00922   // ////////////////////////////////////////////////////////////////////
00923   void BomDisplay::
00924   csvDisplay (std::ostream& oStream,
00925               const TravelSolutionList_T& iTravelSolutionList) {
00926 
00927     // Save the formatting flags for the given STL output stream
00928     FlagSaver flagSaver (oStream);
00929 
00930     oStream << "Travel solutions:";
00931     unsigned short idx = 0;
00932     for (TravelSolutionList_T::const_iterator itTS =
00933            iTravelSolutionList.begin();
00934          itTS != iTravelSolutionList.end(); ++itTS, ++idx) {
00935       const TravelSolutionStruct& lTS = *itTS;
00936 
00937       oStream << std::endl;
00938       oStream << "    [" << idx << "] " << lTS.display();
00939     }
00940   }
00941 
00942   // ////////////////////////////////////////////////////////////////////
00943   void BomDisplay::
00944   csvDisplay (std::ostream& oStream,
00945               const DatePeriodList_T& iDatePeriodList) {
00946 
00947     // Save the formatting flags for the given STL output stream
00948     FlagSaver flagSaver (oStream);
00949 
00950     // Browse the date-period objects
00951     for (DatePeriodList_T::const_iterator itDP = iDatePeriodList.begin();
00952          itDP != iDatePeriodList.end(); ++itDP) {
00953       const DatePeriod* lDP_ptr = *itDP;
00954       assert (lDP_ptr != NULL);
00955       
00956       // Display the date-period object
00957       csvDateDisplay (oStream, *lDP_ptr);
00958     }   
00959   }
00960 
00961   // ////////////////////////////////////////////////////////////////////
00962   void BomDisplay::csvSimFQTAirRACDisplay (std::ostream& oStream,
00963                                            const BomRoot& iBomRoot) {
00964     // Save the formatting flags for the given STL output stream
00965     FlagSaver flagSaver (oStream);
00966 
00970     oStream << std::endl;
00971     oStream << "==============================================================="
00972             << std::endl;
00973     oStream << "BomRoot: " << iBomRoot.describeKey() << std::endl;
00974     oStream << "==============================================================="
00975             << std::endl;
00976 
00977     // Check whether there are airport-pair objects
00978     if (BomManager::hasList<AirportPair> (iBomRoot) == false) {
00979       return;
00980     }
00981     
00982     // Browse the airport-pair objects
00983     const AirportPairList_T& lAirportPairList =
00984       BomManager::getList<AirportPair> (iBomRoot);
00985     for (AirportPairList_T::const_iterator itAir = lAirportPairList.begin();
00986          itAir != lAirportPairList.end(); ++itAir ) {
00987       const AirportPair* lAir_ptr = *itAir;
00988       assert (lAir_ptr != NULL);
00989 
00990       // Display the airport pair object
00991       csvAirportPairDisplay (oStream, *lAir_ptr);
00992     }
00993   }
00994 
00995   // ////////////////////////////////////////////////////////////////////
00996   void BomDisplay::csvAirportPairDisplay (std::ostream& oStream,
00997                                           const AirportPair& iAirportPair) {
00998     // Save the formatting flags for the given STL output stream
00999     FlagSaver flagSaver (oStream);
01000 
01004     oStream << "+++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
01005     oStream << "AirportPair: " << iAirportPair.describeKey() << std::endl;
01006     oStream << "+++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
01007     
01008     // Check whether there are date-period objects
01009     if (BomManager::hasList<DatePeriod> (iAirportPair) == false) {
01010       return;
01011     }
01012 
01013     // Browse the date-period objects
01014     const DatePeriodList_T& lDatePeriodList =
01015       BomManager::getList<DatePeriod> (iAirportPair);
01016     for (DatePeriodList_T::const_iterator itDP = lDatePeriodList.begin();
01017          itDP != lDatePeriodList.end(); ++itDP) {
01018       const DatePeriod* lDP_ptr = *itDP;
01019       assert (lDP_ptr != NULL);
01020       
01021       // Display the date-period object
01022       csvDateDisplay (oStream, *lDP_ptr);
01023     }   
01024   }
01025 
01026   // ////////////////////////////////////////////////////////////////////
01027   void BomDisplay::csvDateDisplay (std::ostream& oStream,
01028                                    const DatePeriod& iDatePeriod) {
01029 
01030     // Save the formatting flags for the given STL output stream
01031     FlagSaver flagSaver (oStream);
01032 
01036     oStream << "------------------------------------------" << std::endl;
01037     oStream << "DatePeriod: " << iDatePeriod.describeKey() << std::endl;
01038     oStream << "------------------------------------------" << std::endl;
01039 
01040     // Check whether there are pos-channel objects
01041     if (BomManager::hasList<PosChannel> (iDatePeriod) == false) {
01042       return;
01043     }
01044 
01045     // Browse the pos-channel objects
01046     const PosChannelList_T& lPosChannelList =
01047       BomManager::getList<PosChannel> (iDatePeriod);
01048     for (PosChannelList_T::const_iterator itPC = lPosChannelList.begin();
01049          itPC != lPosChannelList.end(); ++itPC) {
01050       const PosChannel* lPC_ptr = *itPC;
01051       assert (lPC_ptr != NULL);
01052       
01053       // Display the pos-channel object
01054       csvPosChannelDisplay (oStream, *lPC_ptr);
01055     }   
01056   }
01057   
01058   // ////////////////////////////////////////////////////////////////////
01059   void BomDisplay::csvPosChannelDisplay (std::ostream& oStream,
01060                                          const PosChannel& iPosChannel) {
01061     // Save the formatting flags for the given STL output stream
01062     FlagSaver flagSaver (oStream);
01063 
01067     oStream << "******************************************" << std::endl;
01068     oStream << "PosChannel: " << iPosChannel.describeKey() << std::endl;
01069     oStream << "******************************************" << std::endl;
01070 
01071     // Check whether there are time-period objects
01072     if (BomManager::hasList<TimePeriod> (iPosChannel) == false) {
01073       return;
01074     }
01075 
01076     // Browse the time-period objects
01077     const TimePeriodList_T& lTimePeriodList =
01078       BomManager::getList<TimePeriod> (iPosChannel);
01079     for (TimePeriodList_T::const_iterator itTP = lTimePeriodList.begin();
01080          itTP != lTimePeriodList.end(); ++itTP) {
01081       const TimePeriod* lTP_ptr = *itTP;
01082       assert (lTP_ptr != NULL);
01083       
01084       // Display the time-period object
01085       csvTimeDisplay (oStream, *lTP_ptr);
01086     }
01087   }
01088   
01089   // ////////////////////////////////////////////////////////////////////
01090   void BomDisplay::csvTimeDisplay (std::ostream& oStream,
01091                                    const TimePeriod& iTimePeriod) {
01092 
01093     // Save the formatting flags for the given STL output stream
01094     FlagSaver flagSaver (oStream);
01095 
01099     oStream << "----------------------------------------" << std::endl;
01100     oStream << "TimePeriod: " << iTimePeriod.describeKey() << std::endl;
01101     oStream << "----------------------------------------" << std::endl;
01102 
01103     // Only one of the fare/yield feature list exists. Each of the following
01104     // two methods will check for the existence of the list. So, only the
01105     // existing list will be actually displayed.
01106     csvFeatureListDisplay<FareFeatures> (oStream, iTimePeriod);
01107     csvFeatureListDisplay<YieldFeatures> (oStream, iTimePeriod);
01108   }
01109 
01110   // ////////////////////////////////////////////////////////////////////
01111   template <typename FEATURE_TYPE>
01112   void BomDisplay::csvFeatureListDisplay (std::ostream& oStream,
01113                                           const TimePeriod& iTimePeriod) {
01114 
01115     // Check whether there are fare/yield-feature objects
01116     if (BomManager::hasList<FEATURE_TYPE> (iTimePeriod) == false) {
01117       return;
01118     }
01119 
01120     // Browse the fare/yield-feature objects
01121     typedef typename BomHolder<FEATURE_TYPE>::BomList_T FeaturesList_T;
01122     const FeaturesList_T& lFeaturesList =
01123       BomManager::getList<FEATURE_TYPE> (iTimePeriod);
01124     for (typename FeaturesList_T::const_iterator itFF = lFeaturesList.begin();
01125          itFF != lFeaturesList.end(); ++itFF) {
01126       const FEATURE_TYPE* lFF_ptr = *itFF;
01127       assert (lFF_ptr != NULL);
01128 
01129       // Display the fare-features object
01130       csvFeaturesDisplay (oStream, *lFF_ptr);
01131     }
01132   }
01133   
01134   // ////////////////////////////////////////////////////////////////////
01135   template <typename FEATURE_TYPE>
01136   void BomDisplay::csvFeaturesDisplay (std::ostream& oStream,
01137                                        const FEATURE_TYPE& iFeatures) {
01138     // Save the formatting flags for the given STL output stream
01139     FlagSaver flagSaver (oStream);
01140 
01144     oStream << "--------------------------------------" << std::endl;
01145     oStream << "Fare/yield-Features: " << iFeatures.describeKey() << std::endl;
01146     oStream << "--------------------------------------" << std::endl;
01147    
01148     // Check whether there are airlineClassList objects
01149     if (BomManager::hasList<AirlineClassList> (iFeatures) == false) {
01150       return;
01151     }
01152     
01153     // Browse the airlineClassList objects
01154     const AirlineClassListList_T& lAirlineClassListList =
01155       BomManager::getList<AirlineClassList> (iFeatures);
01156     for (AirlineClassListList_T::const_iterator itACL =
01157            lAirlineClassListList.begin();
01158          itACL != lAirlineClassListList.end(); ++itACL) {
01159       const AirlineClassList* lACL_ptr = *itACL;
01160       assert (lACL_ptr != NULL);
01161 
01162       // Display the airlineClassList object
01163       csvAirlineClassDisplay(oStream, *lACL_ptr);
01164     }
01165   }
01166 
01167   // ////////////////////////////////////////////////////////////////////
01168   void BomDisplay::
01169   csvAirlineClassDisplay  (std::ostream& oStream,
01170                            const AirlineClassList& iAirlineClassList) {
01171     // Save the formatting flags for the given STL output stream
01172     FlagSaver flagSaver (oStream);
01173 
01177     oStream << "------------------------------------" << std::endl;
01178     oStream << "AirlineClassList: "
01179             << iAirlineClassList.describeKey() << std::endl;
01180     oStream << "------------------------------------" << std::endl;
01181   }
01182     
01183 }
01184