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