OBTServiceManager.h

Go to the documentation of this file.

#ifndef OBTServiceManager_H
#define OBTServiceManager_H

#include <map>
#include <typeinfo>

#include "OBT.h"
#include "OBTSingleton.h"
#include "OBTIService.h"
#include "OBT_ASSERT.h"

namespace OBT
{
        class OBT_API ServiceManager
        {
                friend class Singleton< ServiceManager > ;

        public:

                template <class TService>
                friend TService* getService( unsigned int ID = 0 ) ;
                template <class TService>
                friend const std::map< unsigned int, IService* >* getServices() ;

                template <class TService>
                friend void addService( TService* service, unsigned int ID = 0 ) ;

                template <class TService>
                friend void removeService( unsigned int ID = 0 ) ;

        private:

                ServiceManager() ;

                ServiceManager( const ServiceManager& ) ;

                virtual ~ServiceManager() ;

                const ServiceManager& operator=( const ServiceManager& ) ;

                typedef std::map< std::string, std::map< unsigned int, IService* > >
                        ServicesMap ;

                ServicesMap _services ;
        } ;

        template class OBT_API Singleton< ServiceManager > ;

        //-------------------------------------------------------------------------
        // getService
        //-------------------------------------------------------------------------
        template <class TService>
        TService* getService( unsigned int ID /*= 0*/ )
        {
                ServiceManager::ServicesMap& services( Singleton< ServiceManager >::getInstance()._services ) ;
                ServiceManager::ServicesMap::iterator servicesIte( services.find( typeid( TService ).name() ) ) ;
                if ( servicesIte != services.end() )
                {
                        std::map< unsigned int, IService* >::iterator ite( servicesIte->second.find( ID ) ) ;
                        if ( ite != servicesIte->second.end() )
                        {
                                return static_cast<TService*>( ite->second ) ;
                        }
                }
                TRACE_WARNING( "The following service was not found : " << typeid( TService ).name() << " with id " << ID ) ;
                return NULL ;
        }

        //-------------------------------------------------------------------------
        // getServices
        //-------------------------------------------------------------------------
        template <class TService>
        const std::map< unsigned int, IService* >* getServices()
        {
                const std::map< unsigned int, IService* >* servicesFound = 0 ;
                ServiceManager::ServicesMap& services( Singleton< ServiceManager >::getInstance()._services ) ;
                ServiceManager::ServicesMap::const_iterator servicesIte( services.find( typeid( TService ).name() ) ) ;
                if ( servicesIte != services.end() )
                {
                        servicesFound = &servicesIte->second ;
                }
                else
                {
                        TRACE_WARNING( "The following services was not found : " << typeid( TService ).name() ) ;
                }
                return servicesFound ;
        }

        //-------------------------------------------------------------------------
        // addService
        //-------------------------------------------------------------------------
        template <class TService>
        inline void addService( TService* service, unsigned int ID /*= 0*/ ) 
        {
                OBT_DBG_ASSERT( service != NULL ) ;
                ServiceManager::ServicesMap::mapped_type& serviceMap
                        ( Singleton< ServiceManager >::getInstance()._services[ typeid( TService ).name() ] ) ;
                serviceMap[ ID ] = service ;
        }

        //-------------------------------------------------------------------------
        // removeService
        //-------------------------------------------------------------------------
        template <class TService>
        inline void removeService( unsigned int ID /*= 0*/ ) 
        {
                ServiceManager::ServicesMap::iterator servicesIte
                        ( Singleton< ServiceManager >::getInstance()._services.find( typeid( TService ).name() ) ) ;
                if ( servicesIte != Singleton< ServiceManager >::getInstance()._services.end() )
                {
                        std::map< unsigned int, IService* >::iterator ite( servicesIte->second.find( ID ) ) ;
                        if ( ite != servicesIte->second.end() )
                        {
                                servicesIte->second.erase( ite ) ;
                                if ( servicesIte->second.empty() )
                                {
                                        Singleton< ServiceManager >::getInstance()._services.erase( servicesIte ) ;
                                }
                        }
                }
        }
}
#endif //OBTServiceManager_H

---