CmdBomSerialiser.cpp

Go to the documentation of this file.

// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <cassert>
#include <sstream>
// Boost.Serialization
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/access.hpp>
// StdAir
#include <stdair/basic/BasConst_General.hpp>
#include <stdair/basic/BasConst_Inventory.hpp>
#include <stdair/bom/BomRoot.hpp>
#include <stdair/bom/Inventory.hpp>
#include <stdair/bom/FlightDate.hpp>
#include <stdair/bom/SegmentDate.hpp>
#include <stdair/bom/SegmentCabin.hpp>
#include <stdair/bom/FareFamily.hpp>
#include <stdair/bom/LegDate.hpp>
#include <stdair/bom/LegCabin.hpp>
#include <stdair/bom/Bucket.hpp>
#include <stdair/factory/FacBomManager.hpp>
#include <stdair/factory/FacBom.hpp>
#include <stdair/command/CmdBomSerialiser.hpp>
#include <stdair/service/Logger.hpp>

namespace stdair {

  // ////////////////////////////////////////////////////////////////////
  template <class Archive, class BOM_OBJECT1, class BOM_OBJECT2>
  void serialiseHelper (BOM_OBJECT1& ioObject1, Archive& ioArchive,
                        const unsigned int iFileVersion) {

    BomHolder<BOM_OBJECT2>* lBomHolder_ptr =
      FacBomManager::getBomHolderPtr<BOM_OBJECT2> (ioObject1);

    if (lBomHolder_ptr == NULL) {
      lBomHolder_ptr = &FacBomManager::addBomHolder<BOM_OBJECT2> (ioObject1);
    }
    assert (lBomHolder_ptr != NULL);

    //ioArchive.register_type (static_cast<Inventory*> (NULL));
    ioArchive & lBomHolder_ptr->_bomList;
    ioArchive & lBomHolder_ptr->_bomMap;

    typedef typename BomHolder<BOM_OBJECT2>::BomList_T BomList_T;
    const BomList_T& lBomList = lBomHolder_ptr->_bomList;
    for (typename BomList_T::const_iterator itObject = lBomList.begin();
         itObject != lBomList.end(); ++itObject) {
      BOM_OBJECT2* lObject2_ptr = *itObject;
      assert (lObject2_ptr != NULL);

      if (lObject2_ptr->getParent() == NULL) {
        FacBomManager::linkWithParent (ioObject1, *lObject2_ptr);
      }
    }

    typedef typename BomHolder<BOM_OBJECT2>::BomMap_T BomMap_T;
    const BomMap_T& lBomMap = lBomHolder_ptr->_bomMap;
    if (lBomList.empty() == true && lBomMap.empty() == false) {

      for (typename BomMap_T::const_iterator itObject = lBomMap.begin();
           itObject != lBomMap.end(); ++itObject) {
        BOM_OBJECT2* lObject2_ptr = itObject->second;
        assert (lObject2_ptr != NULL);

        if (lObject2_ptr->getParent() == NULL) {
          FacBomManager::linkWithParent (ioObject1, *lObject2_ptr);
        }
      }
    }
  }

  // ////////////////////////////////////////////////////////////////////
  void BomRoot::serialisationImplementationExport() const {
    std::ostringstream oStr;
    boost::archive::text_oarchive oa (oStr);
    oa << *this;
  }

  // ////////////////////////////////////////////////////////////////////
  void BomRoot::serialisationImplementationImport() {
    std::istringstream iStr;
    boost::archive::text_iarchive ia (iStr);
    ia >> *this;
  }

  // ////////////////////////////////////////////////////////////////////
  template<class Archive>
  void BomRoot::serialize (Archive& ioArchive,
                           const unsigned int iFileVersion) {
    // Serialise the key (by default, equal to " -- ROOT -- ")
    ioArchive & _key;

    // Serialise the children of the BomRoot object, i.e., the
    // Inventory children
    stdair::serialiseHelper<Archive, BomRoot, Inventory> (*this, ioArchive,
                                                          iFileVersion);
  }

  // ////////////////////////////////////////////////////////////////////
  void Inventory::serialisationImplementationExport() const {
    std::ostringstream oStr;
    boost::archive::text_oarchive oa (oStr);
    oa << *this;
  }

  // ////////////////////////////////////////////////////////////////////
  void Inventory::serialisationImplementationImport() {
    std::istringstream iStr;
    boost::archive::text_iarchive ia (iStr);
    ia >> *this;
  }

  // ////////////////////////////////////////////////////////////////////
  template<class Archive>
  void Inventory::serialize (Archive& ioArchive,
                             const unsigned int iFileVersion) {
    // Serialise the key (airline code)
    ioArchive & _key;

    // Serialise the children of the Inventory object, i.e., the
    // FlightDate children
    stdair::serialiseHelper<Archive, Inventory, FlightDate> (*this, ioArchive,
                                                             iFileVersion);
  }

  // ////////////////////////////////////////////////////////////////////
  void FlightDate::serialisationImplementationExport() const {
    std::ostringstream oStr;
    boost::archive::text_oarchive oa (oStr);
    oa << *this;
  }

  // ////////////////////////////////////////////////////////////////////
  void FlightDate::serialisationImplementationImport() {
    std::istringstream iStr;
    boost::archive::text_iarchive ia (iStr);
    ia >> *this;
  }

  // ////////////////////////////////////////////////////////////////////
  template<class Archive>
  void FlightDate::serialize (Archive& ioArchive,
                             const unsigned int iFileVersion) {
    ioArchive & _key;
  }

  // ////////////////////////////////////////////////////////////////////
  void SegmentDate::serialisationImplementationExport() const {
    std::ostringstream oStr;
    boost::archive::text_oarchive oa (oStr);
    oa << *this;
  }

  // ////////////////////////////////////////////////////////////////////
  void SegmentDate::serialisationImplementationImport() {
    std::istringstream iStr;
    boost::archive::text_iarchive ia (iStr);
    ia >> *this;
  }

  // ////////////////////////////////////////////////////////////////////
  template<class Archive>
  void SegmentDate::serialize (Archive& ioArchive,
                             const unsigned int iFileVersion) {
    ioArchive & _key;
  }

  // ////////////////////////////////////////////////////////////////////
  void SegmentCabin::serialisationImplementationExport() const {
    std::ostringstream oStr;
    boost::archive::text_oarchive oa (oStr);
    oa << *this;
  }

  // ////////////////////////////////////////////////////////////////////
  void SegmentCabin::serialisationImplementationImport() {
    std::istringstream iStr;
    boost::archive::text_iarchive ia (iStr);
    ia >> *this;
  }

  // ////////////////////////////////////////////////////////////////////
  template<class Archive>
  void SegmentCabin::serialize (Archive& ioArchive,
                                const unsigned int iFileVersion) {
    ioArchive & _key;
  }

  // ////////////////////////////////////////////////////////////////////
  // Explicit template instantiations
  namespace ba = boost::archive;
  template void BomRoot::serialize<ba::text_oarchive> (ba::text_oarchive&,
                                                       unsigned int);
  template void BomRoot::serialize<ba::text_iarchive> (ba::text_iarchive&,
                                                       unsigned int);
  template void Inventory::serialize<ba::text_oarchive> (ba::text_oarchive&,
                                                         unsigned int);
  template void Inventory::serialize<ba::text_iarchive> (ba::text_iarchive&,
                                                         unsigned int);
  template void FlightDate::serialize<ba::text_oarchive> (ba::text_oarchive&,
                                                          unsigned int);
  template void FlightDate::serialize<ba::text_iarchive> (ba::text_iarchive&,
                                                          unsigned int);
  template void SegmentDate::serialize<ba::text_oarchive> (ba::text_oarchive&,
                                                           unsigned int);
  template void SegmentDate::serialize<ba::text_iarchive> (ba::text_iarchive&,
                                                           unsigned int);
  template void SegmentCabin::serialize<ba::text_oarchive> (ba::text_oarchive&,
                                                            unsigned int);
  template void SegmentCabin::serialize<ba::text_iarchive> (ba::text_iarchive&,
                                                            unsigned int);
  // ////////////////////////////////////////////////////////////////////

}