FactoryListBase.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 ossimFactoryListBase_HEADER
#define ossimFactoryListBase_HEADER 1
#include <vector>
#include <ossim/base/ossimString.h>
#include <ossim/base/RWLock.h>

namespace ossim
{
  template <class T>
  class FactoryListBase
     {
     public:
        typedef std::vector<T> FactoryListType;
        typedef std::vector<ossimString> TypeNameList;

        FactoryListBase(){}
        
        void addFactory(T factory)
        {
           registerFactory(factory);
        }
        
        bool isFactoryRegistered(T factory)const
        {
           if(!factory) return false;
           ScopeReadLock scopedReadLock(m_rwlock);
           
           return findFactory(factory);
        }
        
        void registerFactory(T factory, bool pushToFrontFlag=false)
        {
           if(!factory) return;
           ScopeWriteLock scopedWriteLock(m_rwlock);
           if(!findFactory(factory))
           {
              if (pushToFrontFlag)
              {
                 m_factoryList.insert(m_factoryList.begin(), factory);
              }
              else
              {
                 m_factoryList.push_back(factory);
              }
           }
        }
        void unregisterFactory(T factory)
        {
          ScopeWriteLock scopedWriteLock(m_rwlock);
          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 unregisterAllFactories()
        {
          ScopeWriteLock scopedWriteLock(m_rwlock);
          m_factoryList.clear();
        }
        
        void registerFactoryToFront(T factory)
        {
          ScopeWriteLock scopedWriteLock(m_rwlock);
          if(!findFactory(factory))
          {
            m_factoryList.insert(m_factoryList.begin(), factory);
          }
        }
        
        void registerFactoryBefore(T factory, T beforeThisFactory)
        {
          ScopeWriteLock scopedWriteLock(m_rwlock);

           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);
           }
        }
        
     protected:
        bool findFactory(T factory)const
        {
           if(!factory) return false;
           ossim_uint32 idx = 0;
           for(const auto& testFactory:m_factoryList)
           {
              if(factory == testFactory)
              {
                return true;
              }
           }
           return false;
        }

        mutable ossim::RWLock m_rwlock;
        FactoryListType m_factoryList;
     };
}

#endif