FacBom.hpp

Go to the documentation of this file.

#ifndef __STDAIR_FAC_FACBOM_HPP
#define __STDAIR_FAC_FACBOM_HPP

// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <cassert>
#include <string>
#include <list>
// StdAir 
#include <stdair/factory/FacAbstract.hpp>
#include <stdair/service/FacSupervisor.hpp>
#include <stdair/service/Logger.hpp>

namespace stdair {  

  template <typename BOM>
  class FacBom : public FacAbstract {

    typedef std::list<BOM*> BomPool_T;
    typedef typename BOM::Key_T Key_T;


  public:
    // ///////////// Business methods ////////////
    static FacBom& instance();

    BOM& create ();
    BOM& create (const Key_T&);
    BOM& create (const BOM&);
    
  protected:
    FacBom() {}

  public:
    ~FacBom() {
      clean();
    }

    void clean();
    

  private:
    // ///////////////////// Attributes //////////////////
    static FacBom* _instance;

    BomPool_T _pool;
  };


  // ////////////////////////////////////////////////////////////////////
  template <typename BOM> FacBom<BOM>* FacBom<BOM>::_instance = NULL;
  
  // ////////////////////////////////////////////////////////////////////
  template <typename BOM> FacBom<BOM>& FacBom<BOM>::instance () {
    if (_instance == NULL) {
      _instance = new FacBom ();
      assert (_instance != NULL);

      FacSupervisor::instance().registerPersistentBomFactory (_instance);
    }
    return *_instance;
  }

  // ////////////////////////////////////////////////////////////////////
  template <typename BOM> void FacBom<BOM>::clean () {
    // Destroy all the objects
    for (typename BomPool_T::iterator itBom = _pool.begin();
         itBom != _pool.end(); ++itBom) {
      BOM* currentBom_ptr = *itBom;
      assert (currentBom_ptr != NULL);
      delete currentBom_ptr; currentBom_ptr = NULL;
    }

    // Empty the pool.
    _pool.clear();

    // Reset the static instance.
    _instance = NULL;
  }
  
  // ////////////////////////////////////////////////////////////////////
  template <typename BOM> BOM& FacBom<BOM>::create () {
    Key_T lKey;
    return instance().create (lKey);
  }
  
  // ////////////////////////////////////////////////////////////////////
  template <typename BOM> BOM& FacBom<BOM>::create (const Key_T& iKey) {
    BOM* oBom_ptr = new BOM (iKey);
    assert (oBom_ptr != NULL);
    _pool.push_back (oBom_ptr);
    return *oBom_ptr;
  }

  // ////////////////////////////////////////////////////////////////////
  template <typename BOM> BOM& FacBom<BOM>::create (const BOM& iBom) {
    BOM* oBom_ptr = new BOM (iBom);
    assert (oBom_ptr != NULL);
    _pool.push_back (oBom_ptr);
    return *oBom_ptr;
  }
  
}
#endif // __STDAIR_FAC_FACBOM_HPP