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/SegmentSnapshotTable.hpp>
24 #include <stdair/bom/TravelSolutionStruct.hpp>
25 #include <stdair/bom/FareOptionStruct.hpp>
26 #include <stdair/bom/EventStruct.hpp>
27 #include <stdair/bom/SnapshotStruct.hpp>
28 #include <stdair/bom/RMEventStruct.hpp>
29 #include <stdair/bom/FareFamily.hpp>
30 #include <stdair/bom/BookingClass.hpp>
31 #include <stdair/bom/BomRetriever.hpp>
32 #include <stdair/factory/FacBomManager.hpp>
33 #include <stdair/factory/FacBom.hpp>
34 #include <stdair/service/Logger.hpp>
35 #include <sevmgr/SEVMGR_Service.hpp>
47 void InventoryManager::
48 calculateAvailability (
const stdair::BomRoot& iBomRoot,
49 stdair::TravelSolutionStruct& ioTravelSolution) {
51 stdair::PartnershipTechnique::EN_PartnershipTechnique lENPartnershipTechnique =
52 stdair::PartnershipTechnique::NONE;
56 const stdair::SegmentPath_T& lSegmentPath =
57 ioTravelSolution.getSegmentPath();
58 for (stdair::SegmentPath_T::const_iterator itSK = lSegmentPath.begin();
59 itSK != lSegmentPath.end(); ++itSK) {
60 const std::string& lSegmentKey = *itSK;
61 const stdair::InventoryKey lInvKey =
62 stdair::BomKeyManager::extractInventoryKey (lSegmentKey);
63 stdair::Inventory& lInventory =
64 stdair::BomManager::getObject<stdair::Inventory>(iBomRoot,
67 lENPartnershipTechnique = lInventory.getPartnershipTechnique();
69 switch (lENPartnershipTechnique) {
71 case stdair::PartnershipTechnique::NONE:{
85 switch (lENPartnershipTechnique) {
86 case stdair::PartnershipTechnique::NONE:{
88 calculateAvailabilityByAU (ioTravelSolution);
91 case stdair::PartnershipTechnique::RAE_DA:
92 case stdair::PartnershipTechnique::RAE_YP:{
94 calculateAvailabilityByRAE (ioTravelSolution);
97 case stdair::PartnershipTechnique::IBP_DA:
98 case stdair::PartnershipTechnique::IBP_YP:{
100 calculateAvailabilityByProtectiveIBP (ioTravelSolution);
103 case stdair::PartnershipTechnique::IBP_YP_U:
104 case stdair::PartnershipTechnique::RMC:
105 case stdair::PartnershipTechnique::A_RMC:{
107 calculateAvailabilityByIBP (ioTravelSolution);
119 void InventoryManager::
120 calculateAvailabilityByAU (stdair::TravelSolutionStruct& ioTravelSolution) {
123 std::ostringstream oStr;
124 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
125 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
126 itSP != lSP.end(); itSP++) {
127 oStr << *itSP <<
";";
131 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
132 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
133 itFO != lFOList.end(); ++itFO) {
135 stdair::FareOptionStruct& lFO = *itFO;
138 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
140 const stdair::ClassAvailabilityMapHolder_T& lClassAvailabilityMapHolder =
141 ioTravelSolution.getClassAvailabilityMapHolder();
144 stdair::Availability_T lAvl =
145 std::numeric_limits<stdair::Availability_T>::max();
150 assert (lClassAvailabilityMapHolder.empty() ==
false
151 && lClassPath.empty() ==
false);
154 stdair::ClassAvailabilityMapHolder_T::const_iterator itCAMH =
155 lClassAvailabilityMapHolder.begin();
158 stdair::ClassList_StringList_T::const_iterator itClassList =
162 for (; itCAMH != lClassAvailabilityMapHolder.end()
163 && itClassList != lClassPath.end(); ++itCAMH, ++itClassList) {
166 const stdair::ClassList_String_T& lCurrentClassList = *itClassList;
167 assert (lCurrentClassList.size() > 0);
172 stdair::ClassCode_T lFirstClass;
173 lFirstClass.append (lCurrentClassList, 0, 1);
176 const stdair::ClassAvailabilityStruct& lClassAvlStruct = *itCAMH;
177 const stdair::ClassAvailabilityMap_T& lClassAvlMap =
178 lClassAvlStruct.getClassAvailabilityMap();
181 const stdair::ClassAvailabilityMap_T::const_iterator itClassAvl =
182 lClassAvlMap.find (lFirstClass);
184 if (itClassAvl == lClassAvlMap.end()) {
186 STDAIR_LOG_DEBUG (
"No availability has been set up for the class '"
187 << lFirstClass <<
"'. Travel solution: "
188 << ioTravelSolution.display());
190 assert (itClassAvl != lClassAvlMap.end());
192 const stdair::Availability_T& lCurrentAvl = itClassAvl->second;
193 if (lAvl > lCurrentAvl) {
198 lFO.setAvailability (lAvl);
201 STDAIR_LOG_DEBUG (
"Fare option " << lFO.describe() <<
", "
202 <<
"Availability " << lFO.getAvailability() <<
", "
203 <<
"Segment Path " << oStr.str());
210 void InventoryManager::
211 calculateAvailabilityByRAE (stdair::TravelSolutionStruct& ioTravelSolution) {
213 std::ostringstream oStr;
214 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
215 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
216 itSP != lSP.end(); itSP++) {
217 oStr << *itSP <<
";";
221 const stdair::ClassYieldMapHolder_T& lClassYieldMapHolder =
222 ioTravelSolution.getClassYieldMapHolder();
223 const stdair::ClassBpvMapHolder_T& lClassBpvMapHolder =
224 ioTravelSolution.getClassBpvMapHolder();
227 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
228 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
229 itFO != lFOList.end(); ++itFO) {
231 stdair::FareOptionStruct& lFO = *itFO;
233 stdair::ClassYieldMapHolder_T::const_iterator itCYM =
234 lClassYieldMapHolder.begin();
235 stdair::ClassBpvMapHolder_T::const_iterator itCBPM =
236 lClassBpvMapHolder.begin();
238 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
242 assert (lClassPath.size() == lClassYieldMapHolder.size());
243 assert (lClassPath.size() == lClassBpvMapHolder.size());
248 std::ostringstream oCPStr;
249 for (stdair::ClassList_StringList_T::const_iterator itCL =
251 itCL != lClassPath.end(); ++itCL, ++itCYM, ++itCBPM) {
254 if (itCL == lClassPath.begin()) {
258 oCPStr <<
"-" << *itCL;
261 const stdair::ClassList_String_T& lCL = *itCL;
262 stdair::ClassCode_T lCC;
263 lCC.append (lCL, 0, 1);
265 const stdair::ClassYieldMap_T& lCYM = *itCYM;
266 stdair::ClassYieldMap_T::const_iterator itCCCYM = lCYM.find (lCC);
267 assert (itCCCYM != lCYM.end());
269 const stdair::ClassBpvMap_T& lCBPM = *itCBPM;
270 stdair::ClassBpvMap_T::const_iterator itCCCBPM = lCBPM.find (lCC);
271 assert (itCCCBPM != lCBPM.end());
273 const stdair::BidPriceVector_T* lBidPriceVector_ptr = itCCCBPM->second;
274 assert (lBidPriceVector_ptr != NULL);
277 if (itCL == lClassPath.begin()) {
278 lFO.setAvailability (lBidPriceVector_ptr->size());
282 if (lFO.getAvailability() > 0) {
285 stdair::BidPriceVector_T lReverseBPV (lBidPriceVector_ptr->size());
286 std::reverse_copy (lBidPriceVector_ptr->begin(),
287 lBidPriceVector_ptr->end(),
288 lReverseBPV.begin());
290 const stdair::YieldValue_T& lYield = itCCCYM->second;
291 stdair::BidPriceVector_T::const_iterator lBidPrice =
292 std::upper_bound (lReverseBPV.begin(), lReverseBPV.end(), lYield);
294 const stdair::Availability_T lAvl = lBidPrice - lReverseBPV.begin();
297 lFO.setAvailability (std::min (lFO.getAvailability(), lAvl));
302 STDAIR_LOG_DEBUG (
"Fare option: " << lFO.describe() <<
", "
303 <<
"Availability: " << lFO.getAvailability() <<
", "
304 <<
"Segment Path: " << oStr.str() <<
", ");
311 void InventoryManager::
312 calculateAvailabilityByIBP (stdair::TravelSolutionStruct& ioTravelSolution) {
313 std::ostringstream oStr;
318 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
319 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
320 itSP != lSP.end(); itSP++) {
321 oStr << *itSP <<
";";
325 const stdair::ClassYieldMapHolder_T& lClassYieldMapHolder =
326 ioTravelSolution.getClassYieldMapHolder();
327 const stdair::ClassBpvMapHolder_T& lClassBpvMapHolder =
328 ioTravelSolution.getClassBpvMapHolder();
331 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
332 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
333 itFO != lFOList.end(); ++itFO) {
335 stdair::FareOptionStruct& lFO = *itFO;
337 stdair::ClassYieldMapHolder_T::const_iterator itCYM =
338 lClassYieldMapHolder.begin();
339 stdair::ClassBpvMapHolder_T::const_iterator itCBPM =
340 lClassBpvMapHolder.begin();
342 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
345 assert (lClassPath.size() == lClassYieldMapHolder.size());
346 assert (lClassPath.size() == lClassBpvMapHolder.size());
351 stdair::YieldValue_T lTotalYield = lFO.getFare();
353 stdair::BidPrice_T lTotalBidPrice = 0;
358 std::ostringstream oCPStr;
359 for (stdair::ClassList_StringList_T::const_iterator itCL =
361 itCL != lClassPath.end(); ++itCL, ++itCYM, ++itCBPM) {
364 if (itCL == lClassPath.begin()) {
368 oCPStr <<
"-" << *itCL;
371 const stdair::ClassList_String_T& lCL = *itCL;
372 stdair::ClassCode_T lCC;
373 lCC.append (lCL, 0, 1);
375 const stdair::ClassYieldMap_T& lCYM = *itCYM;
376 stdair::ClassYieldMap_T::const_iterator itCCCYM = lCYM.find (lCC);
377 assert (itCCCYM != lCYM.end());
379 const stdair::ClassBpvMap_T& lCBPM = *itCBPM;
380 stdair::ClassBpvMap_T::const_iterator itCCCBPM = lCBPM.find (lCC);
381 assert (itCCCBPM != lCBPM.end());
383 const stdair::BidPriceVector_T* lBidPriceVector_ptr = itCCCBPM->second;
384 assert (lBidPriceVector_ptr != NULL);
387 if (itCL == lClassPath.begin()) {
388 lFO.setAvailability (lBidPriceVector_ptr->size());
392 if (lFO.getAvailability() > 0) {
394 stdair::BidPriceVector_T lReverseBPV (lBidPriceVector_ptr->size());
395 std::reverse_copy (lBidPriceVector_ptr->begin(),
396 lBidPriceVector_ptr->end(), lReverseBPV.begin());
398 const stdair::YieldValue_T& lYield = itCCCYM->second;
399 stdair::BidPriceVector_T::const_iterator lBidPrice =
400 std::upper_bound (lReverseBPV.begin(), lReverseBPV.end(), lYield);
402 const stdair::Availability_T lAvl = lBidPrice - lReverseBPV.begin();
405 lFO.setAvailability (std::min(lFO.getAvailability(), lAvl));
409 if (lBidPriceVector_ptr->size() > 0) {
410 lTotalBidPrice += lBidPriceVector_ptr->back();
413 lTotalBidPrice = std::numeric_limits<stdair::BidPrice_T>::max();
421 if (lClassPath.size() > 1) {
422 if (lFO.getAvailability() > 0) {
423 const stdair::Availability_T lAvl =
424 alpha * lTotalYield >= lTotalBidPrice;
425 lFO.setAvailability (lAvl * lFO.getAvailability());
428 const stdair::Availability_T lAvl =
429 alpha * lTotalYield >= lTotalBidPrice;
430 lFO.setAvailability (lAvl);
434 STDAIR_LOG_DEBUG (
"Class: " << oCPStr.str()
435 <<
", " <<
"Yield: " << alpha*lTotalYield <<
", "
436 <<
"Bid price: " << lTotalBidPrice <<
", "
437 <<
"Remaining capacity: " <<
"Undefined" <<
" "
438 <<
"Segment date: " << oStr.str());
442 STDAIR_LOG_DEBUG (
"Fare option " << lFO.describe() <<
", "
443 <<
"Availability " << lFO.getAvailability() <<
", "
444 <<
"Segment Path " << oStr.str() <<
", ");
451 void InventoryManager::
452 calculateAvailabilityByProtectiveIBP (stdair::TravelSolutionStruct& ioTravelSolution) {
453 std::ostringstream oStr;
458 const stdair::SegmentPath_T& lSP = ioTravelSolution.getSegmentPath();
459 for (stdair::SegmentPath_T::const_iterator itSP = lSP.begin();
460 itSP != lSP.end(); itSP++) {
461 oStr << *itSP <<
";";
465 const stdair::ClassYieldMapHolder_T& lClassYieldMapHolder =
466 ioTravelSolution.getClassYieldMapHolder();
467 const stdair::ClassBpvMapHolder_T& lClassBpvMapHolder =
468 ioTravelSolution.getClassBpvMapHolder();
471 stdair::FareOptionList_T& lFOList = ioTravelSolution.getFareOptionListRef();
472 for (stdair::FareOptionList_T::iterator itFO = lFOList.begin();
473 itFO != lFOList.end(); ++itFO) {
475 stdair::FareOptionStruct& lFO = *itFO;
477 stdair::ClassYieldMapHolder_T::const_iterator itCYM =
478 lClassYieldMapHolder.begin();
479 stdair::ClassBpvMapHolder_T::const_iterator itCBPM =
480 lClassBpvMapHolder.begin();
482 const stdair::ClassList_StringList_T& lClassPath = lFO.getClassPath();
485 assert (lClassPath.size() == lClassYieldMapHolder.size());
486 assert (lClassPath.size() == lClassBpvMapHolder.size());
490 stdair::YieldValue_T lTotalYield = lFO.getFare();
492 stdair::BidPrice_T lTotalBidPrice = 0;
494 stdair::BidPrice_T lMaxBidPrice = 0;
499 std::ostringstream oCPStr;
500 for (stdair::ClassList_StringList_T::const_iterator itCL =
502 itCL != lClassPath.end(); ++itCL, ++itCYM, ++itCBPM) {
505 if (itCL == lClassPath.begin()) {
509 oCPStr <<
"-" << *itCL;
512 const stdair::ClassList_String_T& lCL = *itCL;
513 stdair::ClassCode_T lCC;
514 lCC.append (lCL, 0, 1);
516 const stdair::ClassYieldMap_T& lCYM = *itCYM;
517 stdair::ClassYieldMap_T::const_iterator itCCCYM = lCYM.find (lCC);
518 assert (itCCCYM != lCYM.end());
520 const stdair::YieldValue_T& lYield = itCCCYM->second;
521 const stdair::ClassBpvMap_T& lCBPM = *itCBPM;
522 stdair::ClassBpvMap_T::const_iterator itCCCBPM = lCBPM.find (lCC);
523 assert (itCCCBPM != lCBPM.end());
525 const stdair::BidPriceVector_T* lBidPriceVector_ptr = itCCCBPM->second;
526 assert (lBidPriceVector_ptr != NULL);
529 if (itCL == lClassPath.begin()) {
530 lFO.setAvailability (lBidPriceVector_ptr->size());
534 if (lFO.getAvailability() > 0) {
537 stdair::BidPriceVector_T lReverseBPV (lBidPriceVector_ptr->size());
538 std::reverse_copy (lBidPriceVector_ptr->begin(),
539 lBidPriceVector_ptr->end(), lReverseBPV.begin());
541 stdair::BidPriceVector_T::const_iterator lBidPrice =
542 std::upper_bound (lReverseBPV.begin(), lReverseBPV.end(), lYield);
544 const stdair::Availability_T lAvl = lBidPrice - lReverseBPV.begin();
547 lFO.setAvailability (std::min(lFO.getAvailability(), lAvl));
552 if (lBidPriceVector_ptr->size() > 0) {
553 lTotalBidPrice += lBidPriceVector_ptr->back();
555 if (lMaxBidPrice < lBidPriceVector_ptr->back()) {
556 lMaxBidPrice = lBidPriceVector_ptr->back();
560 lTotalBidPrice = std::numeric_limits<stdair::BidPrice_T>::max();
571 lTotalBidPrice = std::max (lMaxBidPrice * lClassPath.size(),
574 if (lClassPath.size() > 1) {
575 if (lFO.getAvailability() > 0) {
576 const stdair::Availability_T lAvl =
577 alpha * lTotalYield >= lTotalBidPrice;
578 lFO.setAvailability (lAvl * lFO.getAvailability());
581 const stdair::Availability_T lAvl =
582 alpha * lTotalYield >= lTotalBidPrice;
583 lFO.setAvailability (lAvl);
587 STDAIR_LOG_DEBUG (
"Class: " << oCPStr.str()
588 <<
", " <<
"Yield: " << alpha*lTotalYield <<
", "
589 <<
"Bid price: " << lTotalBidPrice <<
", "
590 <<
"Remaining capacity: " <<
"Undefined" <<
" "
591 <<
"Segment date: " << oStr.str());
595 STDAIR_LOG_DEBUG (
"Fare option " << lFO.describe() <<
", "
596 <<
"Availability " << lFO.getAvailability() <<
", "
597 <<
"Segment Path " << oStr.str() <<
", ");
605 const stdair::InventoryList_T& lInvList =
606 stdair::BomManager::getList<stdair::Inventory> (ioBomRoot);
607 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
608 itInv != lInvList.end(); ++itInv) {
609 stdair::Inventory* lCurrentInv_ptr = *itInv;
610 assert (lCurrentInv_ptr != NULL);
617 if (stdair::BomManager::hasList<stdair::Inventory> (*lCurrentInv_ptr)) {
618 const stdair::InventoryList_T& lPartnerInvList =
619 stdair::BomManager::getList<stdair::Inventory> (*lCurrentInv_ptr);
621 for (stdair::InventoryList_T::const_iterator itPartnerInv =
622 lPartnerInvList.begin();
623 itPartnerInv != lPartnerInvList.end(); ++itPartnerInv) {
624 stdair::Inventory* lCurrentPartnerInv_ptr = *itPartnerInv;
625 assert (lCurrentPartnerInv_ptr != NULL);
637 const stdair::FlightDateList_T& lFlightDateList =
638 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
639 for (stdair::FlightDateList_T::const_iterator itFlightDate =
640 lFlightDateList.begin();
641 itFlightDate != lFlightDateList.end(); ++itFlightDate) {
642 stdair::FlightDate* lCurrentFlightDate_ptr = *itFlightDate;
643 assert (lCurrentFlightDate_ptr != NULL);
647 if (stdair::BomManager::hasList<stdair::LegDate> (*lCurrentFlightDate_ptr)) {
648 const stdair::LegDateList_T& lLegDateList =
649 stdair::BomManager::getList<stdair::LegDate> (*lCurrentFlightDate_ptr);
650 for (stdair::LegDateList_T::const_iterator itLegDate =
651 lLegDateList.begin();
652 itLegDate != lLegDateList.end(); ++itLegDate) {
653 stdair::LegDate* lCurrentLegDate_ptr = *itLegDate;
654 assert (lCurrentLegDate_ptr != NULL);
656 const stdair::LegCabinList_T& lLegCabinList =
657 stdair::BomManager::getList<stdair::LegCabin> (*lCurrentLegDate_ptr);
658 for (stdair::LegCabinList_T::const_iterator itLegCabin =
659 lLegCabinList.begin();
660 itLegCabin != lLegCabinList.end(); ++itLegCabin) {
661 stdair::LegCabin* lCurrentLegCabin_ptr = *itLegCabin;
662 assert (lCurrentLegCabin_ptr != NULL);
664 const stdair::CabinCapacity_T& lCabinCapacity =
665 lCurrentLegCabin_ptr->getPhysicalCapacity();
666 lCurrentLegCabin_ptr->emptyBidPriceVector();
668 stdair::BidPriceVector_T& lBPV =
669 lCurrentLegCabin_ptr->getBidPriceVector();
672 for (stdair::CabinCapacity_T k = 0; k != lCabinCapacity; k++) {
673 lBPV.push_back (400);
676 lCurrentLegCabin_ptr->setPreviousBidPrice (lBPV.back());
677 lCurrentLegCabin_ptr->setCurrentBidPrice (lBPV.back());
685 bool InventoryManager::sell (stdair::Inventory& ioInventory,
686 const std::string& iSegmentDateKey,
687 const stdair::ClassCode_T& iClassCode,
688 const stdair::PartySize_T& iPartySize) {
692 iClassCode, iPartySize);
696 bool InventoryManager::sell (
const stdair::BookingClassID_T& iClassID,
697 const stdair::PartySize_T& iPartySize) {
704 bool InventoryManager::cancel (stdair::Inventory& ioInventory,
705 const std::string& iSegmentDateKey,
706 const stdair::ClassCode_T& iClassCode,
707 const stdair::PartySize_T& iPartySize) {
711 iClassCode, iPartySize);
715 bool InventoryManager::cancel (
const stdair::BookingClassID_T& iClassID,
716 const stdair::PartySize_T& iPartySize) {
723 void InventoryManager::
724 updateBookingControls (stdair::FlightDate& ioFlightDate) {
731 void InventoryManager::
732 recalculateAvailability (stdair::FlightDate& ioFlightDate) {
739 void InventoryManager::takeSnapshots(
const stdair::Inventory& iInventory,
740 const stdair::DateTime_T& iSnapshotTime){
752 const stdair::InventoryList_T& lInvList =
753 stdair::BomManager::getList<stdair::Inventory> (iBomRoot);
754 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
755 itInv != lInvList.end(); ++itInv) {
756 stdair::Inventory* lCurrentInv_ptr = *itInv;
757 assert (lCurrentInv_ptr != NULL);
764 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
765 itInv != lInvList.end(); ++itInv) {
766 stdair::Inventory* lCurrentInv_ptr = *itInv;
767 assert (lCurrentInv_ptr != NULL);
779 stdair::Inventory& ioInventory) {
783 const stdair::FlightDateList_T& lFlightDateList =
784 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
785 for (stdair::FlightDateList_T::const_iterator itFlightDate =
786 lFlightDateList.begin();
787 itFlightDate != lFlightDateList.end(); ++itFlightDate) {
788 stdair::FlightDate* lCurrentFlightDate_ptr = *itFlightDate;
789 assert (lCurrentFlightDate_ptr != NULL);
796 const bool hasInventoryList =
797 stdair::BomManager::hasList<stdair::Inventory> (ioInventory);
798 if (hasInventoryList ==
true) {
799 const stdair::InventoryList_T& lInvList =
800 stdair::BomManager::getList<stdair::Inventory> (ioInventory);
801 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
802 itInv != lInvList.end(); ++itInv) {
803 stdair::Inventory* lCurrentInv_ptr = *itInv;
804 assert (lCurrentInv_ptr != NULL);
814 stdair::Inventory& ioInventory,
815 stdair::FlightDate& ioFlightDate) {
817 bool areSegmentAndRoutingLegLinked =
false;
821 const stdair::SegmentDateList_T& lSegmentDateList =
822 stdair::BomManager::getList<stdair::SegmentDate> (ioFlightDate);
823 for (stdair::SegmentDateList_T::const_iterator itSegmentDate =
824 lSegmentDateList.begin();
825 itSegmentDate != lSegmentDateList.end(); ++itSegmentDate) {
827 stdair::SegmentDate* lCurrentSegmentDate_ptr = *itSegmentDate;
828 assert (lCurrentSegmentDate_ptr != NULL);
831 const stdair::RoutingLegKeyList_T& lRoutingLegKeyList =
832 lCurrentSegmentDate_ptr->getLegKeyList ();
836 for (stdair::RoutingLegKeyList_T::const_iterator itRoutingLegKey =
837 lRoutingLegKeyList.begin();
838 itRoutingLegKey != lRoutingLegKeyList.end(); ++itRoutingLegKey) {
841 stdair::LegDate* lLegDate_ptr = stdair::BomRetriever::
842 retrieveOperatingLegDateFromLongKey (ioFlightDate, *itRoutingLegKey);
844 if (lLegDate_ptr != NULL) {
847 stdair::FacBomManager::addToListAndMap (*lCurrentSegmentDate_ptr,
849 stdair::FacBomManager::addToListAndMap (*lLegDate_ptr,
850 *lCurrentSegmentDate_ptr);
851 areSegmentAndRoutingLegLinked =
true;
854 if (areSegmentAndRoutingLegLinked ==
true) {
866 const stdair::SegmentCabinList_T& lSegmentCabinList =
867 stdair::BomManager::getList<stdair::SegmentCabin> (ioSegmentDate);
868 for (stdair::SegmentCabinList_T::const_iterator itSegmentCabin =
869 lSegmentCabinList.begin();
870 itSegmentCabin != lSegmentCabinList.end(); ++itSegmentCabin) {
873 stdair::SegmentCabin* lCurrentSegmentCabin_ptr = *itSegmentCabin;
874 assert (lCurrentSegmentCabin_ptr != NULL);
877 const stdair::CabinCode_T& lCabinCode =
878 lCurrentSegmentCabin_ptr->getCabinCode();
881 const stdair::LegDateList_T& lLegDateList =
882 stdair::BomManager::getList<stdair::LegDate> (ioSegmentDate);
883 for (stdair::LegDateList_T::const_iterator itLegDate =
884 lLegDateList.begin();
885 itLegDate != lLegDateList.end(); ++itLegDate) {
887 const stdair::LegDate* lCurrentLegDate_ptr = *itLegDate;
888 assert (lCurrentLegDate_ptr != NULL);
892 stdair::LegCabin& lLegCabin = stdair::BomManager::
893 getObject<stdair::LegCabin> (*lCurrentLegDate_ptr, lCabinCode);
905 stdair::FacBomManager::addToListAndMap (*lCurrentSegmentCabin_ptr,
907 lLegCabin.getFullerKey());
919 stdair::FacBomManager::
920 addToListAndMap (lLegCabin, *lCurrentSegmentCabin_ptr,
921 lCurrentSegmentCabin_ptr->getFullerKey());
929 stdair::Inventory& ioInventory) {
933 const stdair::FlightDateList_T& lFlightDateList =
934 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
935 for (stdair::FlightDateList_T::const_iterator itFlightDate =
936 lFlightDateList.begin();
937 itFlightDate != lFlightDateList.end(); ++itFlightDate) {
938 stdair::FlightDate* lCurrentFlightDate_ptr = *itFlightDate;
939 assert (lCurrentFlightDate_ptr != NULL);
948 stdair::Inventory& ioInventory,
949 stdair::FlightDate& ioFlightDate) {
953 const stdair::SegmentDateList_T& lSegmentDateList =
954 stdair::BomManager::getList<stdair::SegmentDate> (ioFlightDate);
955 for (stdair::SegmentDateList_T::const_iterator itSegmentDate =
956 lSegmentDateList.begin();
957 itSegmentDate != lSegmentDateList.end(); ++itSegmentDate) {
959 stdair::SegmentDate* lCurrentSegmentDate_ptr = *itSegmentDate;
960 assert (lCurrentSegmentDate_ptr != NULL);
963 const stdair::RoutingLegKeyList_T& lRoutingLegKeyList =
964 lCurrentSegmentDate_ptr->getLegKeyList ();
968 for (stdair::RoutingLegKeyList_T::const_iterator itRoutingLegKey =
969 lRoutingLegKeyList.begin();
970 itRoutingLegKey != lRoutingLegKeyList.end(); ++itRoutingLegKey) {
974 stdair::LegDate* lLegDate_ptr = stdair::BomRetriever::
975 retrieveOperatingLegDateFromLongKey (ioFlightDate, *itRoutingLegKey);
979 if (lLegDate_ptr == NULL) {
983 std::ostringstream lRoutingSegmentKey;
984 lRoutingSegmentKey << *itRoutingLegKey <<
";"
985 << lCurrentSegmentDate_ptr->getOffPoint();
987 stdair::SegmentDate* lPartnerOperatingSegmentDate_ptr =
988 stdair::BomRetriever::
989 retrievePartnerSegmentDateFromLongKey (ioInventory,
990 lRoutingSegmentKey.str());
991 assert (lPartnerOperatingSegmentDate_ptr != NULL);
994 stdair::FacBomManager::linkWithOperating (*lCurrentSegmentDate_ptr,
995 *lPartnerOperatingSegmentDate_ptr);
997 stdair::SegmentDate* lOperatingSegmentDate_ptr =
998 stdair::BomRetriever::
999 retrieveSegmentDateFromLongKey (ioBomRoot,
1000 lRoutingSegmentKey.str());
1001 assert(lOperatingSegmentDate_ptr != NULL);
1003 stdair::Inventory* lInventory_ptr =
1004 stdair::BomRetriever::
1005 retrieveInventoryFromLongKey (ioBomRoot, *itRoutingLegKey);
1006 assert (lInventory_ptr != NULL);
1008 std::ostringstream lRoutingSegment;
1009 lRoutingSegment << ioFlightDate.getAirlineCode() <<
";"
1010 << ioFlightDate.describeKey() <<
";"
1011 << lCurrentSegmentDate_ptr->getBoardingPoint() <<
";"
1012 << lCurrentSegmentDate_ptr->getOffPoint();
1014 stdair::SegmentDate* lPartnerMarketingSegmentDate_ptr =
1015 stdair::BomRetriever::
1016 retrievePartnerSegmentDateFromLongKey (*lInventory_ptr, lRoutingSegment.str());
1017 assert(lPartnerMarketingSegmentDate_ptr != NULL);
1019 stdair::FacBomManager::addToList (*lOperatingSegmentDate_ptr, *lPartnerMarketingSegmentDate_ptr);
1032 const stdair::InventoryList_T& lInvList =
1033 stdair::BomManager::getList<stdair::Inventory> (iBomRoot);
1034 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
1035 itInv != lInvList.end(); ++itInv) {
1036 stdair::Inventory* lCurrentInv_ptr = *itInv;
1037 assert (lCurrentInv_ptr != NULL);
1055 const stdair::FlightDateList_T& lFlightDateList =
1056 stdair::BomManager::getList<stdair::FlightDate> (ioInventory);
1057 for (stdair::FlightDateList_T::const_iterator itFD= lFlightDateList.begin();
1058 itFD != lFlightDateList.end(); ++itFD) {
1059 const stdair::FlightDate* lFD_ptr = *itFD;
1060 assert (lFD_ptr != NULL);
1061 const stdair::FlightNumber_T& lFlightNumber = lFD_ptr->getFlightNumber();
1065 const stdair::SegmentDateList_T& lSegmentDateList =
1066 stdair::BomManager::getList<stdair::SegmentDate> (*lFD_ptr);
1067 for (stdair::SegmentDateList_T::const_iterator itSD =
1068 lSegmentDateList.begin(); itSD != lSegmentDateList.end(); ++itSD) {
1069 const stdair::SegmentDate* lSD_ptr = *itSD;
1070 assert (lSD_ptr != NULL);
1072 const stdair::Date_T& lDepartureDate = lSD_ptr->getBoardingDate();
1073 const stdair::AirportCode_T& lOrigin = lSD_ptr->getBoardingPoint();
1074 const stdair::AirportCode_T& lDestination = lSD_ptr->getOffPoint();
1078 const stdair::SegmentCabinList_T& lSegmentCabinList =
1079 stdair::BomManager::getList<stdair::SegmentCabin> (*lSD_ptr);
1080 for (stdair::SegmentCabinList_T::const_iterator itSC =
1081 lSegmentCabinList.begin();
1082 itSC != lSegmentCabinList.end(); ++itSC) {
1083 stdair::SegmentCabin* lSC_ptr = *itSC;
1084 assert (lSC_ptr != NULL);
1086 std::ostringstream oStr;
1087 oStr << lFlightNumber << lDepartureDate.day_of_week()
1088 << lOrigin << lDestination << lSC_ptr->getCabinCode();
1089 const std::string lMapKey = oStr.str();
1092 SimilarSegmentCabinSetMap_T::iterator itSSCS = lSSCSM.find (lMapKey);
1093 if (itSSCS == lSSCSM.end()) {
1096 value_type (lDepartureDate, lSC_ptr));
1098 value_type (lMapKey, lDDSCMap));
1102 value_type (lDepartureDate, lSC_ptr));
1109 stdair::TableID_T lTableID = 1;
1110 for (SimilarSegmentCabinSetMap_T::const_iterator itSSCS = lSSCSM.begin();
1111 itSSCS != lSSCSM.end(); ++itSSCS, ++lTableID) {
1121 const stdair::TableID_T& iTableID,
1124 const stdair::SegmentSnapshotTableKey lKey (iTableID);
1125 stdair::SegmentSnapshotTable& lSegmentSnapshotTable =
1126 stdair::FacBom<stdair::SegmentSnapshotTable>::instance().create (lKey);
1127 stdair::FacBomManager::addToListAndMap (ioInventory, lSegmentSnapshotTable);
1130 DepartureDateSegmentCabinMap_T::const_iterator itDDSC = iDDSCMap.begin();
1131 assert (itDDSC != iDDSCMap.end());
1132 const stdair::SegmentCabin* lSegmentCabin_ptr = itDDSC->second;
1136 stdair::ClassIndexMap_T lClassIndexMap;
1137 stdair::ClassIndex_T lClassIndex = 0;
1138 std::ostringstream lSCMapKey;
1139 lSCMapKey << stdair::DEFAULT_SEGMENT_CABIN_VALUE_TYPE
1140 << lSegmentCabin_ptr->describeKey();
1141 lClassIndexMap.insert (stdair::ClassIndexMap_T::
1142 value_type (lSCMapKey.str(), lClassIndex));
1146 const stdair::BookingClassList_T& lBCList =
1147 stdair::BomManager::getList<stdair::BookingClass>(*lSegmentCabin_ptr);
1148 for (stdair::BookingClassList_T::const_iterator itBC= lBCList.begin();
1149 itBC != lBCList.end(); ++itBC) {
1150 const stdair::BookingClass* lBookingClass_ptr = *itBC;
1151 assert (lBookingClass_ptr != NULL);
1153 insert (stdair::ClassIndexMap_T::
1154 value_type(lBookingClass_ptr->describeKey(),lClassIndex));
1159 stdair::SegmentCabinIndexMap_T lSegmentCabinIndexMap;
1160 stdair::SegmentDataID_T lSegmentDataID = 0;
1161 for (; itDDSC != iDDSCMap.end(); ++itDDSC, ++lSegmentDataID) {
1162 stdair::SegmentCabin* lCurrentSC_ptr = itDDSC->second;
1163 assert (lCurrentSC_ptr != NULL);
1164 lSegmentCabinIndexMap.
1165 insert (stdair::SegmentCabinIndexMap_T::value_type (lCurrentSC_ptr,
1169 lCurrentSC_ptr->setSegmentSnapshotTable (lSegmentSnapshotTable);
1173 lSegmentSnapshotTable.initSnapshotBlocks(lSegmentCabinIndexMap,
1178 void InventoryManager::initSnapshotEvents (SEVMGR::SEVMGR_ServicePtr_T ioSEVMGR_ServicePtr,
1179 const stdair::Date_T& iStartDate,
1180 const stdair::Date_T& iEndDate) {
1181 const stdair::Duration_T lTimeZero (0, 0, 0);
1182 const stdair::Duration_T lOneDayDuration (24, 0, 0);
1183 const stdair::DateTime_T lBeginSnapshotTime (iStartDate, lTimeZero);
1184 const stdair::DateTime_T lEndSnapshotTime (iEndDate, lTimeZero);
1187 stdair::NbOfEvents_T lNbOfSnapshots = 0.0;
1188 for (stdair::DateTime_T lSnapshotTime = lBeginSnapshotTime;
1189 lSnapshotTime < lEndSnapshotTime; lSnapshotTime += lOneDayDuration) {
1191 stdair::SnapshotPtr_T lSnapshotStruct =
1195 stdair::EventStruct lEventStruct (stdair::EventType::SNAPSHOT,
1205 ioSEVMGR_ServicePtr->addEvent (lEventStruct);
1210 ioSEVMGR_ServicePtr->addStatus (stdair::EventType::SNAPSHOT, lNbOfSnapshots);
1214 void InventoryManager::
1215 initRMEvents (
const stdair::Inventory& iInventory,
1216 stdair::RMEventList_T& ioRMEventList,
1217 const stdair::Date_T& iStartDate,
1218 const stdair::Date_T& iEndDate) {
1219 const stdair::Duration_T lTimeZero (0, 0, 0);
1220 const stdair::Duration_T lTime (0, 0, 10);
1221 const stdair::Duration_T lOneDayDuration (24, 0, 0);
1222 const stdair::DateTime_T lEarliestEventTime (iStartDate, lTimeZero);
1223 const stdair::DateTime_T lLatestEventTime (iEndDate, lTimeZero);
1225 const stdair::AirlineCode_T& lAirlineCode = iInventory.getAirlineCode();
1229 const stdair::FlightDateList_T& lFDList =
1230 stdair::BomManager::getList<stdair::FlightDate> (iInventory);
1231 for (stdair::FlightDateList_T::const_iterator itFD = lFDList.begin();
1232 itFD != lFDList.end(); ++itFD) {
1233 const stdair::FlightDate* lFD_ptr = *itFD;
1234 assert (lFD_ptr != NULL);
1238 const stdair::Date_T& lDepartureDate = lFD_ptr->getDepartureDate();
1239 const stdair::DateTime_T lDepatureDateTime (lDepartureDate, lTime);
1240 for (stdair::DCPList_T::const_iterator itDCP =
1241 stdair::DEFAULT_DCP_LIST.begin();
1242 itDCP != stdair::DEFAULT_DCP_LIST.end(); ++itDCP) {
1243 const stdair::DCP_T& lDCP = *itDCP;
1246 const stdair::DateTime_T lEventTime =
1247 lDepatureDateTime - lOneDayDuration * lDCP;
1248 if (lEventTime >= lEarliestEventTime && lEventTime <= lLatestEventTime){
1249 const stdair::KeyDescription_T lKeyDes = lFD_ptr->describeKey();
1250 stdair::RMEventStruct lRMEvent (lAirlineCode, lKeyDes, lEventTime);
1251 ioRMEventList.push_back (lRMEvent);
1258 void InventoryManager::
1259 addRMEventsToEventQueue (SEVMGR::SEVMGR_ServicePtr_T ioSEVMGR_ServicePtr,
1260 stdair::RMEventList_T& ioRMEventList) {
1262 for (stdair::RMEventList_T::iterator itRMEvent = ioRMEventList.begin();
1263 itRMEvent != ioRMEventList.end(); ++itRMEvent) {
1264 stdair::RMEventStruct& lRMEvent = *itRMEvent;
1265 stdair::RMEventPtr_T lRMEventPtr =
1266 boost::make_shared<stdair::RMEventStruct> (lRMEvent);
1267 stdair::EventStruct lEventStruct (stdair::EventType::RM, lRMEventPtr);
1268 ioSEVMGR_ServicePtr->addEvent (lEventStruct);
1272 const stdair::Count_T lRMEventListSize = ioRMEventList.size();
1273 ioSEVMGR_ServicePtr->addStatus (stdair::EventType::RM, lRMEventListSize);
1281 STDAIR_LOG_DEBUG (
"Initialise the yield-based nesting structure for "
1282 <<
"all segment-cabins");
1285 const stdair::InventoryList_T& lInvList =
1286 stdair::BomManager::getList<stdair::Inventory> (iBomRoot);
1289 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
1290 itInv != lInvList.end(); ++itInv) {
1291 stdair::Inventory* lCurrentInv_ptr = *itInv;
1292 assert (lCurrentInv_ptr != NULL);
1293 const stdair::FlightDateList_T& lFlightDateList =
1294 stdair::BomManager::getList<stdair::FlightDate> (*lCurrentInv_ptr);
1297 for (stdair::FlightDateList_T::const_iterator itFD =
1298 lFlightDateList.begin(); itFD != lFlightDateList.end(); ++itFD) {
1299 const stdair::FlightDate* lFD_ptr = *itFD;
1300 assert (lFD_ptr != NULL);
1301 const stdair::SegmentDateList_T& lSegmentDateList =
1302 stdair::BomManager::getList<stdair::SegmentDate> (*lFD_ptr);
1305 for (stdair::SegmentDateList_T::const_iterator itSD =
1306 lSegmentDateList.begin(); itSD != lSegmentDateList.end(); ++itSD) {
1307 const stdair::SegmentDate* lSD_ptr = *itSD;
1308 assert (lSD_ptr != NULL);
1309 const stdair::SegmentCabinList_T& lSegmentCabinList =
1310 stdair::BomManager::getList<stdair::SegmentCabin> (*lSD_ptr);
1313 for (stdair::SegmentCabinList_T::const_iterator itSC =
1314 lSegmentCabinList.begin(); itSC != lSegmentCabinList.end();
1316 stdair::SegmentCabin* lSC_ptr = *itSC;
1317 assert (lSC_ptr != NULL);
1331 const stdair::InventoryList_T& lInvList =
1332 stdair::BomManager::getList<stdair::Inventory> (iBomRoot);
1335 for (stdair::InventoryList_T::const_iterator itInv = lInvList.begin();
1336 itInv != lInvList.end(); ++itInv) {
1337 stdair::Inventory* lCurrentInv_ptr = *itInv;
1338 assert (lCurrentInv_ptr != NULL);
1342 stdair::PreOptimisationMethod::EN_PreOptimisationMethod lPreOptMethod =
1343 lCurrentInv_ptr->getPreOptimisationMethod();
1345 if (lPreOptMethod == stdair::PreOptimisationMethod::MRT) {
1346 const stdair::FlightDateList_T& lFlightDateList =
1347 stdair::BomManager::getList<stdair::FlightDate> (*lCurrentInv_ptr);
1350 for (stdair::FlightDateList_T::const_iterator itFD =
1351 lFlightDateList.begin(); itFD != lFlightDateList.end(); ++itFD) {
1352 const stdair::FlightDate* lFD_ptr = *itFD;
1353 assert (lFD_ptr != NULL);
1354 const stdair::SegmentDateList_T& lSegmentDateList =
1355 stdair::BomManager::getList<stdair::SegmentDate> (*lFD_ptr);
1358 for (stdair::SegmentDateList_T::const_iterator itSD =
1359 lSegmentDateList.begin();
1360 itSD != lSegmentDateList.end(); ++itSD) {
1361 const stdair::SegmentDate* lSD_ptr = *itSD;
1362 assert (lSD_ptr != NULL);
1363 const stdair::SegmentCabinList_T& lSegmentCabinList =
1364 stdair::BomManager::getList<stdair::SegmentCabin> (*lSD_ptr);
1367 for (stdair::SegmentCabinList_T::const_iterator itSC =
1368 lSegmentCabinList.begin(); itSC != lSegmentCabinList.end();
1370 stdair::SegmentCabin* lSC_ptr = *itSC;
1371 assert (lSC_ptr != NULL);
1373 if (lSC_ptr->getFareFamilyStatus() ==
true) {
static void fillFromRouting(const stdair::BomRoot &)
static void updateBookingControls(stdair::FlightDate &)
static void recalculateAvailability(const stdair::FlightDate &, const stdair::CabinCode_T &)
static bool sell(stdair::Inventory &, const std::string &iSegmentDateKey, const stdair::ClassCode_T &, const stdair::PartySize_T &)
static void calculateAvailability(const stdair::Inventory &, const std::string &, stdair::TravelSolutionStruct &)
static void getYieldAndBidPrice(const stdair::Inventory &, const std::string &, stdair::TravelSolutionStruct &)
static bool cancel(stdair::Inventory &, const std::string &iSegmentDateKey, const stdair::ClassCode_T &, const stdair::PartySize_T &)
static void takeSnapshots(const stdair::Inventory &, const stdair::DateTime_T &)
static void createPartnerAccesses(const stdair::BomRoot &, stdair::Inventory &)
static void createDirectAccesses(const stdair::BomRoot &)
static void setDefaultBidPriceVector(stdair::BomRoot &)
static void buildSimilarSegmentCabinSets(const stdair::BomRoot &)
static void initialiseYieldBasedNestingStructures(const stdair::BomRoot &)
static void initialiseListsOfUsablePolicies(const stdair::BomRoot &)
static void buildSegmentSnapshotTable(stdair::Inventory &, const stdair::TableID_T &, const DepartureDateSegmentCabinMap_T &)
static void initYieldBasedNestingStructure(stdair::SegmentCabin &)
static void initListOfUsablePolicies(stdair::SegmentCabin &)
std::map< const std::string, DepartureDateSegmentCabinMap_T > SimilarSegmentCabinSetMap_T
const std::string DEFAULT_AIRLINE_CODE
std::map< const stdair::Date_T, stdair::SegmentCabin * > DepartureDateSegmentCabinMap_T