8 #include <boost/make_shared.hpp>
10 #include <stdair/basic/BasConst_Inventory.hpp>
11 #include <stdair/basic/BasConst_BomDisplay.hpp>
12 #include <stdair/bom/BomManager.hpp>
13 #include <stdair/bom/BomKeyManager.hpp>
14 #include <stdair/bom/BomRoot.hpp>
15 #include <stdair/bom/Inventory.hpp>
16 #include <stdair/bom/FlightDate.hpp>
17 #include <stdair/bom/SegmentDate.hpp>
18 #include <stdair/bom/SegmentCabin.hpp>
19 #include <stdair/bom/LegDate.hpp>
20 #include <stdair/bom/LegCabin.hpp>
21 #include <stdair/bom/FareFamily.hpp>
22 #include <stdair/bom/BookingClass.hpp>
23 #include <stdair/bom/GuillotineBlock.hpp>
24 #include <stdair/bom/TravelSolutionStruct.hpp>
25 #include <stdair/bom/FareOptionStruct.hpp>
26 #include <stdair/bom/EventStruct.hpp>
27 #include <stdair/bom/EventQueue.hpp>
28 #include <stdair/bom/SnapshotStruct.hpp>
29 #include <stdair/bom/RMEventStruct.hpp>
30 #include <stdair/factory/FacBomManager.hpp>
31 #include <stdair/factory/FacBom.hpp>
32 #include <stdair/service/Logger.hpp>
33 #include <stdair/bom/FareFamily.hpp>
34 #include <stdair/bom/BookingClass.hpp>
45 void InventoryManager::
46 calculateAvailability (
const stdair::BomRoot& iBomRoot,
47 stdair::TravelSolutionStruct& ioTravelSolution,
48 const stdair::PartnershipTechnique& iPartnershipTechnique) {
50 const stdair::PartnershipTechnique::EN_PartnershipTechnique& lPartnershipTechnique =
51 iPartnershipTechnique.getTechnique();
55 const stdair::SegmentPath_T& lSegmentPath =
56 ioTravelSolution.getSegmentPath();
57 for (stdair::SegmentPath_T::const_iterator itSK = lSegmentPath.begin();
58 itSK != lSegmentPath.end(); ++itSK) {
59 const std::string& lSegmentKey = *itSK;
60 const stdair::InventoryKey lInvKey =
61 stdair::BomKeyManager::extractInventoryKey (lSegmentKey);
62 stdair::Inventory& lInventory =
63 stdair::BomManager::getObject<stdair::Inventory>(iBomRoot,
66 switch (lPartnershipTechnique) {
68 case stdair::PartnershipTechnique::NONE:{
81 switch (lPartnershipTechnique) {
82 case stdair::PartnershipTechnique::NONE:{
84 calculateAvailabilityByAU (ioTravelSolution);
87 case stdair::PartnershipTechnique::RAE_DA:
88 case stdair::PartnershipTechnique::RAE_YP:{
90 calculateAvailabilityByRAE (ioTravelSolution);
93 case stdair::PartnershipTechnique::IBP_DA:
94 case stdair::PartnershipTechnique::IBP_YP:{
96 calculateAvailabilityByProtectiveIBP (ioTravelSolution);
99 case stdair::PartnershipTechnique::IBP_YP_U:
100 case stdair::PartnershipTechnique::RMC:
101 case stdair::PartnershipTechnique::A_RMC:{
103 calculateAvailabilityByIBP (ioTravelSolution);
114 void InventoryManager::
115 calculateAvailabilityByAU (stdair::TravelSolutionStruct& ioTravelSolution) {
118 std::ostringstream oStr;
119 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
120 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
121 itSP != lSP.end(); itSP++) {
122 oStr << *itSP <<
";";
126 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
127 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
128 itFO != lFOList.end(); ++itFO) {
130 stdair::FareOptionStruct& lFO = *itFO;
133 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
135 const stdair::ClassAvailabilityMapHolder_T& lClassAvailabilityMapHolder =
136 ioTravelSolution.getClassAvailabilityMapHolder();
139 stdair::Availability_T lAvl =
140 std::numeric_limits<stdair::Availability_T>::max();
145 assert (lClassAvailabilityMapHolder.empty() ==
false
146 && lClassPath.empty() ==
false);
149 stdair::ClassAvailabilityMapHolder_T::const_iterator itCAMH =
150 lClassAvailabilityMapHolder.begin();
153 stdair::ClassList_StringList_T::const_iterator itClassList =
157 for (; itCAMH != lClassAvailabilityMapHolder.end()
158 && itClassList != lClassPath.end(); ++itCAMH, ++itClassList) {
161 const stdair::ClassList_String_T& lCurrentClassList = *itClassList;
162 assert (lCurrentClassList.size() > 0);
167 stdair::ClassCode_T lFirstClass;
168 lFirstClass.append (lCurrentClassList, 0, 1);
171 const stdair::ClassAvailabilityMap_T& lClassAvlMap = *itCAMH;
174 const stdair::ClassAvailabilityMap_T::const_iterator itClassAvl =
175 lClassAvlMap.find (lFirstClass);
177 if (itClassAvl == lClassAvlMap.end()) {
179 STDAIR_LOG_DEBUG (
"No availability has been set up for the class '"
180 << lFirstClass <<
"'. Travel solution: "
181 << ioTravelSolution.display());
183 assert (itClassAvl != lClassAvlMap.end());
185 const stdair::Availability_T& lCurrentAvl = itClassAvl->second;
186 if (lAvl > lCurrentAvl) {
191 lFO.setAvailability (lAvl);
194 STDAIR_LOG_DEBUG (
"Fare option " << lFO.describe() <<
", "
195 <<
"Availability " << lFO.getAvailability() <<
", "
196 <<
"Segment Path " << oStr.str());
203 void InventoryManager::
204 calculateAvailabilityByRAE (stdair::TravelSolutionStruct& ioTravelSolution) {
206 std::ostringstream oStr;
207 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
208 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
209 itSP != lSP.end(); itSP++) {
210 oStr << *itSP <<
";";
214 const stdair::ClassYieldMapHolder_T& lClassYieldMapHolder =
215 ioTravelSolution.getClassYieldMapHolder();
216 const stdair::ClassBpvMapHolder_T& lClassBpvMapHolder =
217 ioTravelSolution.getClassBpvMapHolder();
220 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
221 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
222 itFO != lFOList.end(); ++itFO) {
224 stdair::FareOptionStruct& lFO = *itFO;
226 stdair::ClassYieldMapHolder_T::const_iterator itCYM =
227 lClassYieldMapHolder.begin();
228 stdair::ClassBpvMapHolder_T::const_iterator itCBPM =
229 lClassBpvMapHolder.begin();
231 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
235 assert (lClassPath.size() == lClassYieldMapHolder.size());
236 assert (lClassPath.size() == lClassBpvMapHolder.size());
241 std::ostringstream oCPStr;
242 for (stdair::ClassList_StringList_T::const_iterator itCL =
244 itCL != lClassPath.end(); ++itCL, ++itCYM, ++itCBPM) {
247 if (itCL == lClassPath.begin()) {
251 oCPStr <<
"-" << *itCL;
254 const stdair::ClassList_String_T& lCL = *itCL;
255 stdair::ClassCode_T lCC;
256 lCC.append (lCL, 0, 1);
258 const stdair::ClassYieldMap_T& lCYM = *itCYM;
259 stdair::ClassYieldMap_T::const_iterator itCCCYM = lCYM.find (lCC);
260 assert (itCCCYM != lCYM.end());
262 const stdair::ClassBpvMap_T& lCBPM = *itCBPM;
263 stdair::ClassBpvMap_T::const_iterator itCCCBPM = lCBPM.find (lCC);
264 assert (itCCCBPM != lCBPM.end());
266 const stdair::BidPriceVector_T* lBidPriceVector_ptr = itCCCBPM->second;
267 assert (lBidPriceVector_ptr != NULL);
270 if (itCL == lClassPath.begin()) {
271 lFO.setAvailability (lBidPriceVector_ptr->size());
275 if (lFO.getAvailability() > 0) {
278 stdair::BidPriceVector_T lReverseBPV (lBidPriceVector_ptr->size());
279 std::reverse_copy (lBidPriceVector_ptr->begin(),
280 lBidPriceVector_ptr->end(),
281 lReverseBPV.begin());
283 const stdair::YieldValue_T& lYield = itCCCYM->second;
284 stdair::BidPriceVector_T::const_iterator lBidPrice =
285 std::upper_bound (lReverseBPV.begin(), lReverseBPV.end(), lYield);
287 const stdair::Availability_T lAvl = lBidPrice - lReverseBPV.begin();
290 lFO.setAvailability (std::min (lFO.getAvailability(), lAvl));
295 STDAIR_LOG_DEBUG (
"Fare option: " << lFO.describe() <<
", "
296 <<
"Availability: " << lFO.getAvailability() <<
", "
297 <<
"Segment Path: " << oStr.str() <<
", ");
304 void InventoryManager::
305 calculateAvailabilityByIBP (stdair::TravelSolutionStruct& ioTravelSolution) {
306 std::ostringstream oStr;
311 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
312 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
313 itSP != lSP.end(); itSP++) {
314 oStr << *itSP <<
";";
318 const stdair::ClassYieldMapHolder_T& lClassYieldMapHolder =
319 ioTravelSolution.getClassYieldMapHolder();
320 const stdair::ClassBpvMapHolder_T& lClassBpvMapHolder =
321 ioTravelSolution.getClassBpvMapHolder();
324 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
325 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
326 itFO != lFOList.end(); ++itFO) {
328 stdair::FareOptionStruct& lFO = *itFO;
330 stdair::ClassYieldMapHolder_T::const_iterator itCYM =
331 lClassYieldMapHolder.begin();
332 stdair::ClassBpvMapHolder_T::const_iterator itCBPM =
333 lClassBpvMapHolder.begin();
335 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
338 assert (lClassPath.size() == lClassYieldMapHolder.size());
339 assert (lClassPath.size() == lClassBpvMapHolder.size());
344 stdair::YieldValue_T lTotalYield = lFO.getFare();
346 stdair::BidPrice_T lTotalBidPrice = 0;
351 std::ostringstream oCPStr;
352 for (stdair::ClassList_StringList_T::const_iterator itCL =
354 itCL != lClassPath.end(); ++itCL, ++itCYM, ++itCBPM) {
357 if (itCL == lClassPath.begin()) {
361 oCPStr <<
"-" << *itCL;
364 const stdair::ClassList_String_T& lCL = *itCL;
365 stdair::ClassCode_T lCC;
366 lCC.append (lCL, 0, 1);
368 const stdair::ClassYieldMap_T& lCYM = *itCYM;
369 stdair::ClassYieldMap_T::const_iterator itCCCYM = lCYM.find (lCC);
370 assert (itCCCYM != lCYM.end());
372 const stdair::ClassBpvMap_T& lCBPM = *itCBPM;
373 stdair::ClassBpvMap_T::const_iterator itCCCBPM = lCBPM.find (lCC);
374 assert (itCCCBPM != lCBPM.end());
376 const stdair::BidPriceVector_T* lBidPriceVector_ptr = itCCCBPM->second;
377 assert (lBidPriceVector_ptr != NULL);
380 if (itCL == lClassPath.begin()) {
381 lFO.setAvailability (lBidPriceVector_ptr->size());
385 if (lFO.getAvailability() > 0) {
387 stdair::BidPriceVector_T lReverseBPV (lBidPriceVector_ptr->size());
388 std::reverse_copy (lBidPriceVector_ptr->begin(),
389 lBidPriceVector_ptr->end(), lReverseBPV.begin());
391 const stdair::YieldValue_T& lYield = itCCCYM->second;
392 stdair::BidPriceVector_T::const_iterator lBidPrice =
393 std::upper_bound (lReverseBPV.begin(), lReverseBPV.end(), lYield);
395 const stdair::Availability_T lAvl = lBidPrice - lReverseBPV.begin();
398 lFO.setAvailability (std::min(lFO.getAvailability(), lAvl));
402 if (lBidPriceVector_ptr->size() > 0) {
403 lTotalBidPrice += lBidPriceVector_ptr->back();
406 lTotalBidPrice = std::numeric_limits<stdair::BidPrice_T>::max();
414 if (lClassPath.size() > 1) {
415 if (lFO.getAvailability() > 0) {
416 const stdair::Availability_T lAvl =
417 alpha * lTotalYield >= lTotalBidPrice;
418 lFO.setAvailability (lAvl * lFO.getAvailability());
421 const stdair::Availability_T lAvl =
422 alpha * lTotalYield >= lTotalBidPrice;
423 lFO.setAvailability (lAvl);
427 STDAIR_LOG_DEBUG (
"Class: " << oCPStr.str()
428 <<
", " <<
"Yield: " << alpha*lTotalYield <<
", "
429 <<
"Bid price: " << lTotalBidPrice <<
", "
430 <<
"Remaining capacity: " <<
"Undefined" <<
" "
431 <<
"Segment date: " << oStr.str());
435 STDAIR_LOG_DEBUG (
"Fare option " << lFO.describe() <<
", "
436 <<
"Availability " << lFO.getAvailability() <<
", "
437 <<
"Segment Path " << oStr.str() <<
", ");
444 void InventoryManager::
445 calculateAvailabilityByProtectiveIBP (stdair::TravelSolutionStruct& ioTravelSolution) {
446 std::ostringstream oStr;
451 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
452 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
453 itSP != lSP.end(); itSP++) {
454 oStr << *itSP <<
";";
458 const stdair::ClassYieldMapHolder_T& lClassYieldMapHolder =
459 ioTravelSolution.getClassYieldMapHolder();
460 const stdair::ClassBpvMapHolder_T& lClassBpvMapHolder =
461 ioTravelSolution.getClassBpvMapHolder();
464 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
465 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
466 itFO != lFOList.end(); ++itFO) {
468 stdair::FareOptionStruct& lFO = *itFO;
470 stdair::ClassYieldMapHolder_T::const_iterator itCYM =
471 lClassYieldMapHolder.begin();
472 stdair::ClassBpvMapHolder_T::const_iterator itCBPM =
473 lClassBpvMapHolder.begin();
475 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
478 assert (lClassPath.size() == lClassYieldMapHolder.size());
479 assert (lClassPath.size() == lClassBpvMapHolder.size());
483 stdair::YieldValue_T lTotalYield = lFO.getFare();
485 stdair::BidPrice_T lTotalBidPrice = 0;
487 stdair::BidPrice_T lMaxBidPrice = 0;
492 std::ostringstream oCPStr;
493 for (stdair::ClassList_StringList_T::const_iterator itCL =
495 itCL != lClassPath.end(); ++itCL, ++itCYM, ++itCBPM) {
498 if (itCL == lClassPath.begin()) {
502 oCPStr <<
"-" << *itCL;
505 const stdair::ClassList_String_T& lCL = *itCL;
506 stdair::ClassCode_T lCC;
507 lCC.append (lCL, 0, 1);
509 const stdair::ClassYieldMap_T& lCYM = *itCYM;
510 stdair::ClassYieldMap_T::const_iterator itCCCYM = lCYM.find (lCC);
511 assert (itCCCYM != lCYM.end());
513 const stdair::YieldValue_T& lYield = itCCCYM->second;
514 const stdair::ClassBpvMap_T& lCBPM = *itCBPM;
515 stdair::ClassBpvMap_T::const_iterator itCCCBPM = lCBPM.find (lCC);
516 assert (itCCCBPM != lCBPM.end());
518 const stdair::BidPriceVector_T* lBidPriceVector_ptr = itCCCBPM->second;
519 assert (lBidPriceVector_ptr != NULL);
522 if (itCL == lClassPath.begin()) {
523 lFO.setAvailability (lBidPriceVector_ptr->size());
527 if (lFO.getAvailability() > 0) {
530 stdair::BidPriceVector_T lReverseBPV (lBidPriceVector_ptr->size());
531 std::reverse_copy (lBidPriceVector_ptr->begin(),
532 lBidPriceVector_ptr->end(), lReverseBPV.begin());
534 stdair::BidPriceVector_T::const_iterator lBidPrice =
535 std::upper_bound (lReverseBPV.begin(), lReverseBPV.end(), lYield);
537 const stdair::Availability_T lAvl = lBidPrice - lReverseBPV.begin();
540 lFO.setAvailability (std::min(lFO.getAvailability(), lAvl));
545 if (lBidPriceVector_ptr->size() > 0) {
546 lTotalBidPrice += lBidPriceVector_ptr->back();
548 if (lMaxBidPrice < lBidPriceVector_ptr->back()) {
549 lMaxBidPrice = lBidPriceVector_ptr->back();
553 lTotalBidPrice = std::numeric_limits<stdair::BidPrice_T>::max();
564 lTotalBidPrice = std::max (lMaxBidPrice * lClassPath.size(),
567 if (lClassPath.size() > 1) {
568 if (lFO.getAvailability() > 0) {
569 const stdair::Availability_T lAvl =
570 alpha * lTotalYield >= lTotalBidPrice;
571 lFO.setAvailability (lAvl * lFO.getAvailability());
574 const stdair::Availability_T lAvl =
575 alpha * lTotalYield >= lTotalBidPrice;
576 lFO.setAvailability (lAvl);
580 STDAIR_LOG_DEBUG (
"Class: " << oCPStr.str()
581 <<
", " <<
"Yield: " << alpha*lTotalYield <<
", "
582 <<
"Bid price: " << lTotalBidPrice <<
", "
583 <<
"Remaining capacity: " <<
"Undefined" <<
" "
584 <<
"Segment date: " << oStr.str());
588 STDAIR_LOG_DEBUG (
"Fare option " << lFO.describe() <<
", "
589 <<
"Availability " << lFO.getAvailability() <<
", "
590 <<
"Segment Path " << oStr.str() <<
", ");
598 const stdair::InventoryList_T& lInvList =
599 stdair::BomManager::getList<stdair::Inventory> (ioBomRoot);
600 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
601 itInv != lInvList.end(); ++itInv) {
602 stdair::Inventory* lCurrentInv_ptr = *itInv;
603 assert (lCurrentInv_ptr != NULL);
610 if (stdair::BomManager::hasList<stdair::Inventory> (*lCurrentInv_ptr)) {
611 const stdair::InventoryList_T& lPartnerInvList =
612 stdair::BomManager::getList<stdair::Inventory> (*lCurrentInv_ptr);
614 for (stdair::InventoryList_T::const_iterator itPartnerInv =
615 lPartnerInvList.begin();
616 itPartnerInv != lPartnerInvList.end(); ++itPartnerInv) {
617 stdair::Inventory* lCurrentPartnerInv_ptr = *itPartnerInv;
618 assert (lCurrentPartnerInv_ptr != NULL);
630 const stdair::FlightDateList_T& lFlightDateList =
631 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
632 for (stdair::FlightDateList_T::const_iterator itFlightDate =
633 lFlightDateList.begin();
634 itFlightDate != lFlightDateList.end(); ++itFlightDate) {
635 stdair::FlightDate* lCurrentFlightDate_ptr = *itFlightDate;
636 assert (lCurrentFlightDate_ptr != NULL);
640 if (stdair::BomManager::hasList<stdair::LegDate> (*lCurrentFlightDate_ptr)) {
641 const stdair::LegDateList_T& lLegDateList =
642 stdair::BomManager::getList<stdair::LegDate> (*lCurrentFlightDate_ptr);
643 for (stdair::LegDateList_T::const_iterator itLegDate =
644 lLegDateList.begin();
645 itLegDate != lLegDateList.end(); ++itLegDate) {
646 stdair::LegDate* lCurrentLegDate_ptr = *itLegDate;
647 assert (lCurrentLegDate_ptr != NULL);
649 const stdair::LegCabinList_T& lLegCabinList =
650 stdair::BomManager::getList<stdair::LegCabin> (*lCurrentLegDate_ptr);
651 for (stdair::LegCabinList_T::const_iterator itLegCabin =
652 lLegCabinList.begin();
653 itLegCabin != lLegCabinList.end(); ++itLegCabin) {
654 stdair::LegCabin* lCurrentLegCabin_ptr = *itLegCabin;
655 assert (lCurrentLegCabin_ptr != NULL);
657 const stdair::CabinCapacity_T& lCabinCapacity =
658 lCurrentLegCabin_ptr->getPhysicalCapacity();
659 lCurrentLegCabin_ptr->emptyBidPriceVector();
661 stdair::BidPriceVector_T& lBPV =
662 lCurrentLegCabin_ptr->getBidPriceVector();
665 for (stdair::CabinCapacity_T k = 0; k != lCabinCapacity; k++) {
666 lBPV.push_back (400);
669 lCurrentLegCabin_ptr->setPreviousBidPrice (lBPV.back());
670 lCurrentLegCabin_ptr->setCurrentBidPrice (lBPV.back());
678 bool InventoryManager::sell (stdair::Inventory& ioInventory,
679 const std::string& iSegmentDateKey,
680 const stdair::ClassCode_T& iClassCode,
681 const stdair::PartySize_T& iPartySize) {
685 iClassCode, iPartySize);
689 bool InventoryManager::cancel (stdair::Inventory& ioInventory,
690 const std::string& iSegmentDateKey,
691 const stdair::ClassCode_T& iClassCode,
692 const stdair::PartySize_T& iPartySize) {
696 iClassCode, iPartySize);
700 void InventoryManager::
701 updateBookingControls (stdair::FlightDate& ioFlightDate) {
708 void InventoryManager::takeSnapshots(
const stdair::Inventory& iInventory,
709 const stdair::DateTime_T& iSnapshotTime){
721 const stdair::InventoryList_T& lInvList =
722 stdair::BomManager::getList<stdair::Inventory> (iBomRoot);
723 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
724 itInv != lInvList.end(); ++itInv) {
725 stdair::Inventory* lCurrentInv_ptr = *itInv;
726 assert (lCurrentInv_ptr != NULL);
741 const stdair::FlightDateList_T& lFlightDateList =
742 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
743 for (stdair::FlightDateList_T::const_iterator itFlightDate =
744 lFlightDateList.begin();
745 itFlightDate != lFlightDateList.end(); ++itFlightDate) {
746 stdair::FlightDate* lCurrentFlightDate_ptr = *itFlightDate;
747 assert (lCurrentFlightDate_ptr != NULL);
759 const stdair::SegmentDateList_T& lSegmentDateList =
760 stdair::BomManager::getList<stdair::SegmentDate> (ioFlightDate);
761 for (stdair::SegmentDateList_T::const_iterator itSegmentDate =
762 lSegmentDateList.begin();
763 itSegmentDate != lSegmentDateList.end(); ++itSegmentDate) {
765 stdair::SegmentDate* lCurrentSegmentDate_ptr = *itSegmentDate;
766 assert (lCurrentSegmentDate_ptr != NULL);
773 const stdair::SegmentDate* lOperatingSegmentDate_ptr =
774 lCurrentSegmentDate_ptr->getOperatingSegmentDate ();
775 if (lOperatingSegmentDate_ptr != NULL) {
777 stdair::FlightDate* lOperatingFlightDate_ptr =
778 stdair::BomManager::getParentPtr<stdair::FlightDate>(*lOperatingSegmentDate_ptr);
779 assert (lOperatingFlightDate_ptr != NULL);
783 const stdair::AirportCode_T& lBoardingPoint =
784 lCurrentSegmentDate_ptr->getBoardingPoint();
786 stdair::AirportCode_T currentBoardingPoint = lBoardingPoint;
787 const stdair::AirportCode_T& lOffPoint =
788 lCurrentSegmentDate_ptr->getOffPoint();
795 unsigned short i = 1;
796 while (currentBoardingPoint != lOffPoint
797 && i <= stdair::MAXIMAL_NUMBER_OF_LEGS_IN_FLIGHT) {
799 stdair::LegDate& lLegDate = stdair::BomManager::
800 getObject<stdair::LegDate> (ioFlightDate, currentBoardingPoint);
803 stdair::FacBomManager::addToListAndMap (*lCurrentSegmentDate_ptr,
805 stdair::FacBomManager::addToListAndMap (lLegDate,
806 *lCurrentSegmentDate_ptr);
809 currentBoardingPoint = lLegDate.getOffPoint();
812 assert (i <= stdair::MAXIMAL_NUMBER_OF_LEGS_IN_FLIGHT);
828 const stdair::SegmentCabinList_T& lSegmentCabinList =
829 stdair::BomManager::getList<stdair::SegmentCabin> (ioSegmentDate);
830 for (stdair::SegmentCabinList_T::const_iterator itSegmentCabin =
831 lSegmentCabinList.begin();
832 itSegmentCabin != lSegmentCabinList.end(); ++itSegmentCabin) {
835 stdair::SegmentCabin* lCurrentSegmentCabin_ptr = *itSegmentCabin;
836 assert (lCurrentSegmentCabin_ptr != NULL);
839 const stdair::CabinCode_T& lCabinCode =
840 lCurrentSegmentCabin_ptr->getCabinCode();
843 const stdair::LegDateList_T& lLegDateList =
844 stdair::BomManager::getList<stdair::LegDate> (ioSegmentDate);
845 for (stdair::LegDateList_T::const_iterator itLegDate =
846 lLegDateList.begin();
847 itLegDate != lLegDateList.end(); ++itLegDate) {
849 const stdair::LegDate* lCurrentLegDate_ptr = *itLegDate;
850 assert (lCurrentLegDate_ptr != NULL);
854 stdair::LegCabin& lLegCabin = stdair::BomManager::
855 getObject<stdair::LegCabin> (*lCurrentLegDate_ptr, lCabinCode);
867 stdair::FacBomManager::addToListAndMap (*lCurrentSegmentCabin_ptr,
869 lLegCabin.getFullerKey());
881 stdair::FacBomManager::
882 addToListAndMap (lLegCabin, *lCurrentSegmentCabin_ptr,
883 lCurrentSegmentCabin_ptr->getFullerKey());
893 const stdair::InventoryList_T& lInvList =
894 stdair::BomManager::getList<stdair::Inventory> (iBomRoot);
895 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
896 itInv != lInvList.end(); ++itInv) {
897 stdair::Inventory* lCurrentInv_ptr = *itInv;
898 assert (lCurrentInv_ptr != NULL);
916 const stdair::FlightDateList_T& lFlightDateList =
917 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
918 for (stdair::FlightDateList_T::const_iterator itFD= lFlightDateList.begin();
919 itFD != lFlightDateList.end(); ++itFD) {
920 const stdair::FlightDate* lFD_ptr = *itFD;
921 assert (lFD_ptr != NULL);
922 const stdair::FlightNumber_T& lFlightNumber = lFD_ptr->getFlightNumber();
926 const stdair::SegmentDateList_T& lSegmentDateList =
927 stdair::BomManager::getList<stdair::SegmentDate> (*lFD_ptr);
928 for (stdair::SegmentDateList_T::const_iterator itSD =
929 lSegmentDateList.begin(); itSD != lSegmentDateList.end(); ++itSD) {
930 const stdair::SegmentDate* lSD_ptr = *itSD;
931 assert (lSD_ptr != NULL);
933 const stdair::Date_T& lDepartureDate = lSD_ptr->getBoardingDate();
934 const stdair::AirportCode_T& lOrigin = lSD_ptr->getBoardingPoint();
935 const stdair::AirportCode_T& lDestination = lSD_ptr->getOffPoint();
939 const stdair::SegmentCabinList_T& lSegmentCabinList =
940 stdair::BomManager::getList<stdair::SegmentCabin> (*lSD_ptr);
941 for (stdair::SegmentCabinList_T::const_iterator itSC =
942 lSegmentCabinList.begin();
943 itSC != lSegmentCabinList.end(); ++itSC) {
944 stdair::SegmentCabin* lSC_ptr = *itSC;
945 assert (lSC_ptr != NULL);
947 std::ostringstream oStr;
948 oStr << lFlightNumber << lDepartureDate.day_of_week()
949 << lOrigin << lDestination << lSC_ptr->getCabinCode();
950 const std::string lMapKey = oStr.str();
953 SimilarSegmentCabinSetMap_T::iterator itSSCS = lSSCSM.find (lMapKey);
954 if (itSSCS == lSSCSM.end()) {
957 value_type (lDepartureDate, lSC_ptr));
959 value_type (lMapKey, lDDSCMap));
963 value_type (lDepartureDate, lSC_ptr));
970 stdair::GuillotineNumber_T lGuillotineNumber = 1;
971 for (SimilarSegmentCabinSetMap_T::const_iterator itSSCS = lSSCSM.begin();
972 itSSCS != lSSCSM.end(); ++itSSCS, ++lGuillotineNumber) {
982 const stdair::GuillotineNumber_T& iGuillotineNumber,
985 const stdair::GuillotineBlockKey lKey (iGuillotineNumber);
986 stdair::GuillotineBlock& lGuillotineBlock =
987 stdair::FacBom<stdair::GuillotineBlock>::instance().create (lKey);
988 stdair::FacBomManager::addToListAndMap (ioInventory, lGuillotineBlock);
991 DepartureDateSegmentCabinMap_T::const_iterator itDDSC = iDDSCMap.begin();
992 assert (itDDSC != iDDSCMap.end());
993 const stdair::SegmentCabin* lSegmentCabin_ptr = itDDSC->second;
997 stdair::ValueTypeIndexMap_T lValueTypeIndexMap;
998 stdair::BlockIndex_T lBlockIndex = 0;
999 std::ostringstream lSCMapKey;
1000 lSCMapKey << stdair::DEFAULT_SEGMENT_CABIN_VALUE_TYPE
1001 << lSegmentCabin_ptr->describeKey();
1002 lValueTypeIndexMap.insert (stdair::ValueTypeIndexMap_T::
1003 value_type (lSCMapKey.str(), lBlockIndex));
1007 const stdair::BookingClassList_T& lBCList =
1008 stdair::BomManager::getList<stdair::BookingClass>(*lSegmentCabin_ptr);
1009 for (stdair::BookingClassList_T::const_iterator itBC= lBCList.begin();
1010 itBC != lBCList.end(); ++itBC) {
1011 const stdair::BookingClass* lBookingClass_ptr = *itBC;
1012 assert (lBookingClass_ptr != NULL);
1014 insert (stdair::ValueTypeIndexMap_T::
1015 value_type(lBookingClass_ptr->describeKey(),lBlockIndex));
1020 stdair::SegmentCabinIndexMap_T lSegmentCabinIndexMap;
1021 stdair::BlockNumber_T lBlockNumber = 0;
1022 for (; itDDSC != iDDSCMap.end(); ++itDDSC, ++lBlockNumber) {
1023 stdair::SegmentCabin* lCurrentSC_ptr = itDDSC->second;
1024 assert (lCurrentSC_ptr != NULL);
1025 lSegmentCabinIndexMap.
1026 insert (stdair::SegmentCabinIndexMap_T::value_type (lCurrentSC_ptr,
1030 lCurrentSC_ptr->setGuillotineBlock (lGuillotineBlock);
1034 lGuillotineBlock.initSnapshotBlocks(lSegmentCabinIndexMap,
1035 lValueTypeIndexMap);
1039 void InventoryManager::initSnapshotEvents (
const stdair::Date_T& iStartDate,
1040 const stdair::Date_T& iEndDate,
1041 stdair::EventQueue& ioQueue) {
1042 const stdair::Duration_T lTimeZero (0, 0, 0);
1043 const stdair::Duration_T lOneDayDuration (24, 0, 0);
1044 const stdair::DateTime_T lBeginSnapshotTime (iStartDate, lTimeZero);
1045 const stdair::DateTime_T lEndSnapshotTime (iEndDate, lTimeZero);
1048 stdair::NbOfEvents_T lNbOfSnapshots = 0.0;
1049 for (stdair::DateTime_T lSnapshotTime = lBeginSnapshotTime;
1050 lSnapshotTime < lEndSnapshotTime; lSnapshotTime += lOneDayDuration) {
1052 stdair::SnapshotPtr_T lSnapshotStruct =
1056 stdair::EventStruct lEventStruct (stdair::EventType::SNAPSHOT,
1066 ioQueue.addEvent (lEventStruct);
1070 ioQueue.addStatus (stdair::EventType::SNAPSHOT, lNbOfSnapshots);
1074 void InventoryManager::
1075 initRMEvents (
const stdair::Inventory& iInventory,
1076 stdair::RMEventList_T& ioRMEventList,
1077 const stdair::Date_T& iStartDate,
1078 const stdair::Date_T& iEndDate) {
1079 const stdair::Duration_T lTimeZero (0, 0, 0);
1080 const stdair::Duration_T lTime (0, 0, 10);
1081 const stdair::Duration_T lOneDayDuration (24, 0, 0);
1082 const stdair::DateTime_T lEarliestEventTime (iStartDate, lTimeZero);
1083 const stdair::DateTime_T lLatestEventTime (iEndDate, lTimeZero);
1085 const stdair::AirlineCode_T& lAirlineCode = iInventory.getAirlineCode();
1089 const stdair::FlightDateList_T& lFDList =
1090 stdair::BomManager::getList<stdair::FlightDate> (iInventory);
1091 for (stdair::FlightDateList_T::const_iterator itFD = lFDList.begin();
1092 itFD != lFDList.end(); ++itFD) {
1093 const stdair::FlightDate* lFD_ptr = *itFD;
1094 assert (lFD_ptr != NULL);
1098 const stdair::Date_T& lDepartureDate = lFD_ptr->getDepartureDate();
1099 const stdair::DateTime_T lDepatureDateTime (lDepartureDate, lTime);
1100 for (stdair::DCPList_T::const_iterator itDCP =
1101 stdair::DEFAULT_DCP_LIST.begin();
1102 itDCP != stdair::DEFAULT_DCP_LIST.end(); ++itDCP) {
1103 const stdair::DCP_T& lDCP = *itDCP;
1106 const stdair::DateTime_T lEventTime =
1107 lDepatureDateTime - lOneDayDuration * lDCP;
1108 if (lEventTime >= lEarliestEventTime && lEventTime <= lLatestEventTime){
1109 const stdair::KeyDescription_T lKeyDes = lFD_ptr->describeKey();
1110 stdair::RMEventStruct lRMEvent (lAirlineCode, lKeyDes, lEventTime);
1111 ioRMEventList.push_back (lRMEvent);
1118 void InventoryManager::
1119 addRMEventsToEventQueue (stdair::EventQueue& ioQueue,
1120 stdair::RMEventList_T& ioRMEventList) {
1122 for (stdair::RMEventList_T::iterator itRMEvent = ioRMEventList.begin();
1123 itRMEvent != ioRMEventList.end(); ++itRMEvent) {
1124 stdair::RMEventStruct& lRMEvent = *itRMEvent;
1125 stdair::RMEventPtr_T lRMEventPtr =
1126 boost::make_shared<stdair::RMEventStruct> (lRMEvent);
1127 stdair::EventStruct lEventStruct (stdair::EventType::RM, lRMEventPtr);
1128 ioQueue.addEvent (lEventStruct);
1132 ioQueue.updateStatus (stdair::EventType::RM, ioRMEventList.size());