ossimFactoryListInterface.h

Go to the documentation of this file.

//**************************************************************************************************
//
// License:  MIT
// 
// See LICENSE.txt file in the top level directory for more details.
//
// Description: Class declaration of ossimFactoryListInterface.
//
//**************************************************************************************************
// $Id$
#ifndef ossimFactoryListInterface_HEADER
#define ossimFactoryListInterface_HEADER
#include <vector>
#include <ossim/base/ossimRefPtr.h>
#include <ossim/base/ossimObject.h>
#include <ossim/base/ossimString.h>
#include <ossim/base/ossimKeywordlist.h>
#include <mutex>

template <class T, class NativeType>
class ossimFactoryListInterface
   {
   public:
      typedef std::vector<T*> FactoryListType;
      typedef T FactoryType;
      typedef NativeType NativeReturnType;
      
      ossimFactoryListInterface(){}
      
      void addFactory(T* factory)
      {
         registerFactory(factory);
      }
      
      bool isFactoryRegistered(T* factory)const
      {
         if(!factory) return false;
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         
         return findFactory(factory);
      }
      
      void registerFactory(T* factory, bool pushToFrontFlag=false)
      {
         if(!factory) return;
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         if(!findFactory(factory))
         {
            if (pushToFrontFlag)
            {
               m_factoryList.insert(m_factoryList.begin(), factory);
            }
            else
            {
               m_factoryList.push_back(factory);
            }
         }
      }
      void unregisterFactory(T* factory)
      {
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         ossim_uint32 idx = 0;
         for(idx = 0; idx < m_factoryList.size(); ++idx)
         {
            if(factory == m_factoryList[idx])
            {
               m_factoryList.erase(m_factoryList.begin() + idx);
               return;
            }
         }
      }
      
      void unregisterFactory(const ossimString& factoryTypeName)
      {
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         ossim_uint32 idx = 0;
         for(idx = 0; idx < m_factoryList.size(); ++idx)
         {
            if (m_factoryList[idx])
            {
               ossimString mangledName (typeid(*(m_factoryList[idx])).name());
               if (mangledName.contains(factoryTypeName))
               {
                  m_factoryList.erase(m_factoryList.begin() + idx);
                  return;
               }
            }
         }
      }

      void unregisterAllFactories()
      {
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         m_factoryList.clear();
      }
      
      void registerFactoryToFront(T* factory)
      {
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         if(!findFactory(factory))
         {
            m_factoryList.insert(m_factoryList.begin(), factory);
         }
      }
      
      void registerFactoryBefore(T* factory, T* beforeThisFactory)
      {
         std::lock_guard<std::mutex> lock(m_factoryListMutex);
         if(!findFactory(factory))
         {
            ossim_uint32 idx = 0;
            for(idx = 0; idx < m_factoryList.size(); ++idx)
            {
               if(beforeThisFactory == m_factoryList[idx])
               {
                  m_factoryList.insert(m_factoryList.begin() + idx, factory);
                  return;
               }
            }
            m_factoryList.push_back(factory);
         }
      }
      
      void getAllTypeNamesFromRegistry(std::vector<ossimString>& typeList)const;
      
      ossimObject* createObjectFromRegistry(const ossimString& typeName)const;
      
      ossimObject* createObjectFromRegistry(const ossimKeywordlist& kwl,
                                            const char* prefix=0)const;

      NativeType* createNativeObjectFromRegistry(const ossimString& typeName)const;
      
      NativeType* createNativeObjectFromRegistry(const ossimKeywordlist& kwl,
                                                 const char* prefix=0)const;
   protected:
      bool findFactory(T* factory)const
      {
         if(!factory) return false;
         ossim_uint32 idx = 0;
         for(;idx < m_factoryList.size();++idx)
         {
            if(m_factoryList[idx] == factory)
            {
               return true;
            }
         }
         
         return false;
      }
      mutable std::mutex m_factoryListMutex;
      FactoryListType m_factoryList;
   };

template <class T, class NativeType>
void ossimFactoryListInterface<T, NativeType>::getAllTypeNamesFromRegistry(std::vector<ossimString>& typeList)const
{
   //std::lock_guard<std::mutex> lock(m_factoryListMutex);
   ossim_uint32 idx = 0;
   for(; idx<m_factoryList.size(); ++idx)
   {
      m_factoryList[idx]->getTypeNameList(typeList);
   }
}
template <class T, class NativeType>
ossimObject* ossimFactoryListInterface<T, NativeType>::createObjectFromRegistry(const ossimString& typeName)const
{
   //std::lock_guard<std::mutex> lock(m_factoryListMutex);
   ossimObject* result = 0;
   ossim_uint32 idx = 0;
   for(;((idx<m_factoryList.size())&&!result); ++idx)
   {
      result = m_factoryList[idx]->createObject(typeName);
   }
   return result;
}

template <class T, class NativeType>
ossimObject* ossimFactoryListInterface<T, NativeType>::createObjectFromRegistry(const ossimKeywordlist& kwl,
                                                                                const char* prefix)const
{
   // std::lock_guard<std::mutex> lock(m_factoryListMutex);
   ossimObject* result = 0;
   ossim_uint32 idx = 0;
   for(;((idx<m_factoryList.size())&&!result); ++idx)
   {
      result = m_factoryList[idx]->createObject(kwl, prefix);
   }
   return result;
}

template <class T, class NativeType>
NativeType* ossimFactoryListInterface<T, NativeType>::createNativeObjectFromRegistry(const ossimString& typeName)const
{
   NativeType* result = 0;
   ossimRefPtr<ossimObject> tempObject = createObjectFromRegistry(typeName);
   if(tempObject.valid())
   {
      result = dynamic_cast<NativeType*>(tempObject.get());
      if(result)
      {
         tempObject.release();
      }
   }
   
   return result;
}

template <class T, class NativeType>
NativeType* ossimFactoryListInterface<T, NativeType>::createNativeObjectFromRegistry(const ossimKeywordlist& kwl,
                                                                                     const char* prefix)const
{
   NativeType* result = 0;
   ossimRefPtr<ossimObject> tempObject = createObjectFromRegistry(kwl, prefix);
   if(tempObject.valid())
   {
      result = dynamic_cast<NativeType*>(tempObject.get());
      if(result)
      {
         tempObject.release();
      }
   }
   
   return result;
}

#endif