SegmentCabin.hpp

Go to the documentation of this file.

#ifndef __STDAIR_BOM_SEGMENTCABIN_HPP
#define __STDAIR_BOM_SEGMENTCABIN_HPP

// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <iosfwd>
#include <string>
// StdAir
#include <stdair/stdair_inventory_types.hpp>
#include <stdair/bom/BomAbstract.hpp>
#include <stdair/bom/SegmentCabinKey.hpp>
#include <stdair/bom/SegmentCabinTypes.hpp>
#include <stdair/bom/PolicyTypes.hpp>

namespace boost {
  namespace serialization {
    class access;
  }
}

namespace stdair {
  // Forward declarations
  class SegmentSnapshotTable;
  class Policy;
  
  class SegmentCabin : public BomAbstract {
    template <typename BOM> friend class FacBom;  
    template <typename BOM> friend class FacCloneBom;
    friend class FacBomManager;
    friend class boost::serialization::access;
    
  public:
    // ////////// Type definitions ////////////
    typedef SegmentCabinKey Key_T;


  public:
    // /////////// Getters ///////////// 
    const Key_T& getKey() const {
      return _key;
    }

    BomAbstract* const getParent() const {
      return _parent;
    }

    const HolderMap_T& getHolderMap() const {
      return _holderMap;
    }
    
    const CabinCode_T& getCabinCode() const {
      return _key.getCabinCode();
    }
    
    const MapKey_T getFullerKey() const;

    const SegmentSnapshotTable& getSegmentSnapshotTable() const {
      assert (_segmentSnapshotTable != NULL);
      return *_segmentSnapshotTable;
    }

    const CabinCapacity_T& getCapacity() const {
      return _capacity;
    }

    const BlockSpace_T& getBlockSpace() const {
      return _blockSpace;
    }

    const BlockSpace_T& getMIN() const {
      return _min;
    }

    const UPR_T& getUPR() const {
      return _upr;
    }

    const NbOfBookings_T& getBookingCounter() const {
      return _bookingCounter;
    }

    const CommittedSpace_T& getCommittedSpace() const {
      return _committedSpace;
    }

    const Availability_T& getAvailabilityPool() const {
      return _availabilityPool;
    }

    const BidPrice_T& getCurrentBidPrice() const {
      return _currentBidPrice;
    }

    const BidPriceVector_T& getBidPriceVector() const {
      return _bidPriceVector;
    }

    const bool getFareFamilyStatus() const {
      return _fareFamilyActivation;
    }

    const PolicyList_T& getConvexHull() const {
      return _convexHull;
    }

  public:
    // ///////// Setters //////////
    void setSegmentSnapshotTable (SegmentSnapshotTable& ioTable) {
      _segmentSnapshotTable = &ioTable;
    }

    void setCapacity (const CabinCapacity_T& iCapacity) {
      _capacity = iCapacity;
    }

    void setBlockSpace (const BlockSpace_T& iBlockSpace) {
      _blockSpace = iBlockSpace;
    }

    void setMIN (const BlockSpace_T& iMIN) {
      _min = iMIN;
    }

    void setUPR (const UPR_T& iUPR) {
      _upr = iUPR;
    }

    void setBookingCounter (const NbOfBookings_T& iBookingCounter) {
      _bookingCounter = iBookingCounter;
    }

    void setCommittedSpace (const CommittedSpace_T& iCommittedSpace) {
      _committedSpace = iCommittedSpace;
    }

    void setAvailabilityPool (const Availability_T& iAvailabilityPool) {
      _availabilityPool = iAvailabilityPool;
    }

    void setBidPriceVector (const BidPriceVector_T& iBPV) {
      _bidPriceVector = iBPV;
    }

    void activateFareFamily () {
      _fareFamilyActivation = true;
    }
  
  public:
    // /////////// Business methods //////////
    void updateFromReservation (const NbOfBookings_T&);

    void resetConvexHull () { _convexHull.clear(); }
    
    void addPolicy (Policy&);
    
  public:
    // /////////// Display support methods /////////
    void toStream (std::ostream& ioOut) const {
      ioOut << toString();
    }

    void fromStream (std::istream& ioIn) {
    }

    std::string toString() const;
    
    const std::string describeKey() const {
      return _key.toString();
    }

    const std::string describeConvexHull() const;

    
  public:
    // /////////// (Boost) Serialisation support methods /////////
    template<class Archive>
    void serialize (Archive& ar, const unsigned int iFileVersion);

  private:
    void serialisationImplementationExport() const;
    void serialisationImplementationImport();


  protected:
    // ////////// Constructors and destructors /////////
    SegmentCabin (const Key_T&);

    virtual ~SegmentCabin();

  private:
    SegmentCabin();

    SegmentCabin (const SegmentCabin&);


  protected:
    // ////////// Attributes /////////
    Key_T _key;

    BomAbstract* _parent;
    
    HolderMap_T _holderMap;

    SegmentSnapshotTable* _segmentSnapshotTable;

    CabinCapacity_T _capacity;

    BlockSpace_T _blockSpace;     

    BlockSpace_T _min;

    UPR_T _upr;

    NbOfBookings_T _bookingCounter;

    CommittedSpace_T _committedSpace;

    Availability_T _availabilityPool;

    BidPriceVector_T _bidPriceVector;

    BidPrice_T _currentBidPrice;

    bool _fareFamilyActivation;

    PolicyList_T _convexHull;

  };

}
#endif // __STDAIR_BOM_SEGMENTCABIN_HPP