StdAir Logo  0.43.0
C++ Standard Airline IT Library
FacBomManager.hpp
Go to the documentation of this file.
00001 #ifndef __STDAIR_FAC_FACBOMMANAGER_HPP
00002 #define __STDAIR_FAC_FACBOMMANAGER_HPP
00003 
00004 // //////////////////////////////////////////////////////////////////////
00005 // Import section
00006 // //////////////////////////////////////////////////////////////////////
00007 // STL
00008 #include <iosfwd>
00009 #include <list>
00010 #include <map>
00011 // StdAir
00012 #include <stdair/bom/BomHolder.hpp>
00013 #include <stdair/bom/BomManager.hpp>
00014 #include <stdair/factory/FacAbstract.hpp>
00015 #include <stdair/factory/FacBom.hpp>
00016 
00017 namespace stdair {
00018 
00022   class FacBomManager : public FacAbstract {
00023   public:
00024     // ///////////// Business methods. ////////////
00033     template <typename OBJECT2, typename OBJECT1>
00034     static BomHolder<OBJECT2>* getBomHolderPtr (OBJECT1&);
00035 
00045     template <typename OBJECT2, typename OBJECT1> 
00046     static BomHolder<OBJECT2>& addBomHolder (OBJECT1&);
00047 
00059     template <typename OBJECT1, typename OBJECT2>
00060     static void addToList (OBJECT1&, OBJECT2&);
00061 
00074     template <typename OBJECT1, typename OBJECT2>
00075     static void addToMap (OBJECT1&, OBJECT2&, const MapKey_T&);
00076 
00088     template <typename OBJECT1, typename OBJECT2>
00089     static void addToMap (OBJECT1&, OBJECT2&);
00090 
00102     template <typename OBJECT1, typename OBJECT2>
00103     static void addToListAndMap (OBJECT1&, OBJECT2&);
00104 
00117     template <typename OBJECT1, typename OBJECT2>
00118     static void addToListAndMap (OBJECT1&, OBJECT2&, const MapKey_T&);
00119 
00126     template <typename PARENT, typename CHILD>
00127     static void linkWithParent (PARENT&, CHILD&);
00128 
00139     template <typename OBJECT2, typename OBJECT1>
00140     static void cloneHolder (OBJECT1&, const OBJECT1&);
00141 
00142 
00143   private:
00156     template <typename OBJECT1, typename OBJECT2>
00157     static void addToList (BomHolder<OBJECT2>&, OBJECT1&, OBJECT2&);
00158 
00172     template <typename OBJECT1, typename OBJECT2>
00173     static void addToMap (BomHolder<OBJECT2>&, OBJECT1&, OBJECT2&,
00174                           const MapKey_T&);
00175 
00184     template <typename OBJECT2, typename OBJECT1>
00185     static BomHolder<OBJECT2>& getBomHolder (OBJECT1&);
00186 
00187 
00188   protected:
00194     FacBomManager() { }
00195 
00196   public:
00200     ~FacBomManager() { }
00201   };
00202 
00203 
00204   // ////////////////////////////////////////////////////////////////////
00205   template <typename OBJECT2, typename OBJECT1> 
00206   BomHolder<OBJECT2>& FacBomManager::addBomHolder (OBJECT1& ioObject1) {
00207 
00208     BomHolder<OBJECT2>* lBomHolder_ptr =
00209       &FacBom<BomHolder<OBJECT2> >::instance().create();
00210 
00211     const bool hasInsertBeenSuccessful =
00212       ioObject1._holderMap.insert (typename HolderMap_T::
00213                                    value_type (&typeid (OBJECT2),
00214                                                lBomHolder_ptr)).second;
00215     assert (hasInsertBeenSuccessful == true);
00216 
00217     return *lBomHolder_ptr;
00218   }
00219 
00220   // ////////////////////////////////////////////////////////////////////
00221   template <typename OBJECT2, typename OBJECT1> 
00222   BomHolder<OBJECT2>* FacBomManager::getBomHolderPtr (OBJECT1& ioObject1) {
00223 
00224     BomHolder<OBJECT2>* lBomHolder_ptr = NULL;
00225 
00226     // Find the corresponding BomHolder within the object1, if existing.
00227     HolderMap_T::const_iterator itHolder =
00228       ioObject1._holderMap.find (&typeid (OBJECT2));
00229 
00230     if (itHolder != ioObject1._holderMap.end()) {
00231       lBomHolder_ptr = static_cast<BomHolder<OBJECT2>*> (itHolder->second);
00232     }
00233 
00234     return lBomHolder_ptr;
00235   }
00236 
00237   // ////////////////////////////////////////////////////////////////////
00238   template <typename OBJECT2, typename OBJECT1> 
00239   BomHolder<OBJECT2>& FacBomManager::getBomHolder (OBJECT1& ioObject1) {
00240 
00241     BomHolder<OBJECT2>* lBomHolder_ptr = NULL;
00242 
00243     // Find the corresponding BomHolder within the object1. If it does
00244     // not exist, then create one.
00245     HolderMap_T::const_iterator itHolder =
00246       ioObject1._holderMap.find (&typeid (OBJECT2));
00247 
00248     if (itHolder == ioObject1._holderMap.end()) {
00249       lBomHolder_ptr = &addBomHolder<OBJECT2, OBJECT1> (ioObject1);
00250 
00251     } else {
00252       lBomHolder_ptr = static_cast<BomHolder<OBJECT2>*> (itHolder->second);
00253     }
00254 
00255     assert (lBomHolder_ptr != NULL);
00256 
00257     return *lBomHolder_ptr;
00258   }
00259 
00260   // ////////////////////////////////////////////////////////////////////
00261   template <typename OBJECT1, typename OBJECT2>
00262   void FacBomManager::addToList (BomHolder<OBJECT2>& ioBomHolder,
00263                                  OBJECT1& ioObject1, OBJECT2& ioObject2) {
00264     ioBomHolder._bomList.push_back (&ioObject2);
00265   }
00266 
00267   // ////////////////////////////////////////////////////////////////////
00268   template <typename OBJECT1, typename OBJECT2>
00269   void FacBomManager::addToList (OBJECT1& ioObject1, OBJECT2& ioObject2) {
00270 
00271     BomHolder<OBJECT2>& lBomHolder = getBomHolder<OBJECT2> (ioObject1);
00272 
00273     addToList<OBJECT1, OBJECT2> (lBomHolder, ioObject1, ioObject2);
00274   }
00275 
00276   // ////////////////////////////////////////////////////////////////////
00277   template <typename OBJECT1, typename OBJECT2>
00278   void FacBomManager::addToMap (BomHolder<OBJECT2>& ioBomHolder,
00279                                 OBJECT1& ioObject1, OBJECT2& ioObject2,
00280                                 const MapKey_T& iKey) {
00281 
00282     const bool insertionSucceeded =
00283       ioBomHolder._bomMap.insert (typename std::map<const MapKey_T, OBJECT2*>::
00284                                   value_type (iKey, &ioObject2)).second;
00285 
00286     if (insertionSucceeded == false) {
00287       // Build a nice message, so that the error be fully explicit
00288       std::ostringstream oStr;
00289       oStr << "The given object ('" << iKey
00290            << "') can not be added to the map of '" << ioObject1.describeKey()
00291            << "' object. That map already contains: '";
00292 
00293       unsigned int idx = 0;
00294       for (typename std::map<const MapKey_T, OBJECT2*>::const_iterator iter =
00295              ioBomHolder._bomMap.begin(); 
00296            iter != ioBomHolder._bomMap.end(); ++iter, ++idx) {
00297         const OBJECT2* lCurrentObject_ptr = iter->second;
00298         assert (lCurrentObject_ptr != NULL);
00299 
00300         if (idx != 0) {
00301           oStr << "; ";
00302         }
00303         oStr << lCurrentObject_ptr->describeKey();
00304       }
00305       oStr << "'";
00306 
00307       STDAIR_LOG_ERROR (oStr.str());
00308       throw ObjectLinkingException (oStr.str());
00309     }    
00310   }
00311 
00312   // ////////////////////////////////////////////////////////////////////
00313   template <typename OBJECT1, typename OBJECT2> void FacBomManager::
00314   addToMap (OBJECT1& ioObject1, OBJECT2& ioObject2, const MapKey_T& iKey) {
00315 
00316     BomHolder<OBJECT2>& lBomHolder = getBomHolder<OBJECT2> (ioObject1);
00317 
00318     addToMap<OBJECT1, OBJECT2> (lBomHolder, ioObject1, ioObject2, iKey);
00319   }
00320 
00321   // ////////////////////////////////////////////////////////////////////
00322   template <typename OBJECT1, typename OBJECT2>
00323   void FacBomManager::addToMap (OBJECT1& ioObject1, OBJECT2& ioObject2) {
00324     const MapKey_T& lKey = ioObject2.describeKey();
00325     addToMap (ioObject1, ioObject2, lKey);
00326   }
00327 
00328   // ////////////////////////////////////////////////////////////////////
00329   template <typename OBJECT1, typename OBJECT2>
00330   void FacBomManager::addToListAndMap (OBJECT1& ioObject1, OBJECT2& ioObject2,
00331                                        const MapKey_T& iKey) {
00332 
00333     BomHolder<OBJECT2>& lBomHolder = getBomHolder<OBJECT2> (ioObject1);
00334 
00335     addToList<OBJECT1, OBJECT2> (lBomHolder, ioObject1, ioObject2);
00336     addToMap<OBJECT1, OBJECT2> (lBomHolder, ioObject1, ioObject2, iKey);
00337   }
00338 
00339   // ////////////////////////////////////////////////////////////////////
00340   template <typename OBJECT1, typename OBJECT2> void FacBomManager::
00341   addToListAndMap (OBJECT1& ioObject1, OBJECT2& ioObject2) {
00342     const MapKey_T& lKey = ioObject2.describeKey();
00343     addToListAndMap<OBJECT1, OBJECT2> (ioObject1, ioObject2, lKey);
00344   }
00345 
00346   // ////////////////////////////////////////////////////////////////////
00347   template <typename PARENT, typename CHILD> void FacBomManager::
00348   linkWithParent (PARENT& ioParent,  CHILD& ioChild) {
00349     ioChild._parent = &ioParent;
00350   }
00351 
00352   // ////////////////////////////////////////////////////////////////////
00353   template <typename OBJECT2, typename OBJECT1> void FacBomManager::
00354   cloneHolder (OBJECT1& ioDest, const OBJECT1& iOri) {
00355 
00356     const BomHolder<OBJECT2>& lOriginHolder = 
00357       BomManager::getBomHolder<OBJECT2> (iOri);
00358 
00359     BomHolder<OBJECT2>& lDestHolder = getBomHolder<OBJECT2> (ioDest);
00360     lDestHolder._bomList = lOriginHolder._bomList;
00361     lDestHolder._bomMap = lOriginHolder._bomMap;
00362   }
00363   
00364 }
00365 
00366 #endif // __STDAIR_FAC_FACBOMMANAGER_HPP