StdAir Logo  0.43.0
C++ Standard Airline IT Library
BomManager.hpp
Go to the documentation of this file.
00001 #ifndef __STDAIR_BOM_BOMMANAGER_HPP
00002 #define __STDAIR_BOM_BOMMANAGER_HPP
00003 
00004 // //////////////////////////////////////////////////////////////////////
00005 // Import section
00006 // //////////////////////////////////////////////////////////////////////
00007 // STL
00008 #include <iosfwd>
00009 #include <string>
00010 #include <list>
00011 #include <map>
00012 // StdAir
00013 #include <stdair/stdair_exceptions.hpp>
00014 #include <stdair/bom/BomAbstract.hpp>
00015 #include <stdair/bom/BomHolder.hpp>
00016 #include <stdair/service/Logger.hpp>
00017 
00018 namespace stdair {
00019   
00027   class BomManager {
00028     friend class FacBomManager;
00029     
00030   public:
00034     template <typename OBJECT2, typename OBJECT1>
00035     static const typename BomHolder<OBJECT2>::BomList_T& getList(const OBJECT1&);
00036 
00040     template <typename OBJECT2, typename OBJECT1>
00041     static const typename BomHolder<OBJECT2>::BomMap_T& getMap (const OBJECT1&);
00042 
00046     template <typename OBJECT2, typename OBJECT1>
00047     static bool hasList (const OBJECT1&);
00048 
00052     template <typename OBJECT2, typename OBJECT1>
00053     static bool hasMap (const OBJECT1&);
00054 
00060     template <typename PARENT, typename CHILD>
00061     static PARENT* getParentPtr (const CHILD&);
00062 
00066     template <typename PARENT, typename CHILD>
00067     static PARENT& getParent (const CHILD&);
00068 
00074     template <typename OBJECT2, typename OBJECT1>
00075     static OBJECT2* getObjectPtr (const OBJECT1&, const MapKey_T&);
00076 
00080     template <typename OBJECT2, typename OBJECT1>
00081     static OBJECT2& getObject (const OBJECT1&, const MapKey_T&);
00082 
00083 
00084   private:
00089     template <typename OBJECT2, typename OBJECT1>
00090     static const BomHolder<OBJECT2>& getBomHolder (const OBJECT1&);
00091   };
00092 
00093   // ////////////////////////////////////////////////////////////////////
00094   template <typename OBJECT2, typename OBJECT1> 
00095   const BomHolder<OBJECT2>& BomManager::getBomHolder (const OBJECT1& iObject1) {
00096 
00097     const HolderMap_T& lHolderMap = iObject1.getHolderMap();
00098     
00099     HolderMap_T::const_iterator itHolder = lHolderMap.find (&typeid (OBJECT2));
00100     
00101     if (itHolder == lHolderMap.end()) {
00102       const std::string lName (typeid (OBJECT2).name());
00103       throw NonInitialisedContainerException ("Cannot find the holder of type "
00104                                               + lName + " within: "
00105                                               + iObject1.describeKey());
00106     } 
00107     
00108     const BomHolder<OBJECT2>* lBomHolder_ptr = 
00109       static_cast<const BomHolder<OBJECT2>*> (itHolder->second);
00110     assert (lBomHolder_ptr != NULL);
00111 
00112     return *lBomHolder_ptr;
00113   }
00114   
00115   // ////////////////////////////////////////////////////////////////////
00116   template <typename OBJECT2, typename OBJECT1>
00117   const typename BomHolder<OBJECT2>::BomList_T& BomManager::
00118   getList (const OBJECT1& iObject1) {
00119     const BomHolder<OBJECT2>& lBomHolder = getBomHolder<OBJECT2> (iObject1);
00120     return lBomHolder._bomList;
00121   }
00122   
00123   // ////////////////////////////////////////////////////////////////////
00124   template <typename OBJECT2, typename OBJECT1>
00125   const typename BomHolder<OBJECT2>::BomMap_T& BomManager::
00126   getMap (const OBJECT1& iObject1) {
00127     const BomHolder<OBJECT2>& lBomHolder = getBomHolder<OBJECT2> (iObject1);
00128     return lBomHolder._bomMap;
00129   }
00130   
00131   // ////////////////////////////////////////////////////////////////////
00132   template <typename OBJECT2, typename OBJECT1>
00133   bool BomManager::hasList (const OBJECT1& iObject1) {
00134     const HolderMap_T& lHolderMap = iObject1.getHolderMap();
00135     HolderMap_T::const_iterator itHolder = lHolderMap.find (&typeid (OBJECT2));
00136     
00137     if (itHolder == lHolderMap.end()) {
00138       return false;
00139     }
00140     const BomHolder<OBJECT2>* lBomHolder_ptr = 
00141       static_cast<const BomHolder<OBJECT2>*> (itHolder->second);
00142     assert (lBomHolder_ptr != NULL);
00143 
00144     return !lBomHolder_ptr->_bomList.empty();
00145   }
00146   
00147   // ////////////////////////////////////////////////////////////////////
00148   template <typename OBJECT2, typename OBJECT1>
00149   bool BomManager::hasMap (const OBJECT1& iObject1) {
00150     const HolderMap_T& lHolderMap = iObject1.getHolderMap();
00151     HolderMap_T::const_iterator itHolder = lHolderMap.find (&typeid (OBJECT2));
00152     
00153     if (itHolder == lHolderMap.end()) {
00154       return false;
00155     }
00156     const BomHolder<OBJECT2>* lBomHolder_ptr = 
00157       static_cast<const BomHolder<OBJECT2>*> (itHolder->second);
00158     assert (lBomHolder_ptr != NULL);
00159 
00160     return !lBomHolder_ptr->_bomMap.empty();
00161   }
00162 
00163   // ////////////////////////////////////////////////////////////////////
00164   template <typename PARENT, typename CHILD>
00165   PARENT* BomManager::getParentPtr (const CHILD& iChild) {
00166     PARENT* const lParent_ptr = static_cast<PARENT* const> (iChild.getParent());
00167     return lParent_ptr; 
00168   }
00169 
00170   // ////////////////////////////////////////////////////////////////////
00171   template <typename PARENT, typename CHILD>
00172   PARENT& BomManager::getParent (const CHILD& iChild) {
00173     PARENT* const lParent_ptr = getParentPtr<PARENT> (iChild);
00174     assert (lParent_ptr != NULL);
00175     return *lParent_ptr; 
00176   }
00177 
00178   // ////////////////////////////////////////////////////////////////////
00179   template <typename OBJECT2, typename OBJECT1>
00180   OBJECT2* BomManager::getObjectPtr (const OBJECT1& iObject1,
00181                                      const MapKey_T& iKey) {
00182     OBJECT2* oBom_ptr = NULL;
00183     
00184     const HolderMap_T& lHolderMap = iObject1.getHolderMap();
00185 
00186     typename HolderMap_T::const_iterator itHolder = 
00187       lHolderMap.find (&typeid (OBJECT2));
00188     
00189     if (itHolder != lHolderMap.end()) {
00190     
00191       BomHolder<OBJECT2>* const lBomHolder_ptr = 
00192         static_cast<BomHolder<OBJECT2>* const> (itHolder->second);
00193       assert (lBomHolder_ptr != NULL);
00194 
00195       //
00196       typedef typename BomHolder<OBJECT2>::BomMap_T BomMap_T;
00197       BomMap_T& lBomMap =  lBomHolder_ptr->_bomMap;
00198       typename BomMap_T::iterator itBom = lBomMap.find (iKey);
00199 
00200       if (itBom != lBomMap.end()) {
00201         oBom_ptr = itBom->second;
00202         assert (oBom_ptr != NULL);
00203       }
00204     }
00205 
00206     return oBom_ptr;
00207   }
00208 
00209   // ////////////////////////////////////////////////////////////////////
00210   template <typename OBJECT2, typename OBJECT1>
00211   OBJECT2& BomManager::getObject (const OBJECT1& iObject1,
00212                                   const MapKey_T& iKey) {
00213     OBJECT2* oBom_ptr = NULL;
00214     
00215     typedef std::map<const MapKey_T, OBJECT2*> BomMap_T;
00216     const BomMap_T& lBomMap = getMap<OBJECT2> (iObject1);
00217     
00218     typename BomMap_T::const_iterator itBom = lBomMap.find (iKey);
00219 
00220     if (itBom == lBomMap.end()) {
00221       const std::string lName (typeid (OBJECT2).name());
00222       
00223       STDAIR_LOG_ERROR ("Cannot find the objet of type " << lName
00224                         << " with key " << iKey << " within: " 
00225                         << iObject1.describeKey());
00226       assert (false);
00227     }
00228     
00229     oBom_ptr = itBom->second;
00230     assert (oBom_ptr != NULL);
00231 
00232     return *oBom_ptr;
00233   }
00234   
00235 }
00236 #endif // __STDAIR_BOM_BOMMANAGER_HPP