In-memory database of the loaded factories. More...

#include </builds/gaudi/Gaudi/GaudiPluginService/include/Gaudi/Details/PluginServiceDetailsV1.h>

Collaboration diagram for Gaudi::PluginService::v1::Details::Registry:

Classes
struct	FactoryInfo

Public Types
typedef std::string	KeyType
typedef std::map< KeyType, std::string >	Properties
	Type used for the properties implementation.
typedef std::map< KeyType, FactoryInfo >	FactoryMap
	Type used for the database implementation.

Public Member Functions
template<typename F, typename T, typename I>
FactoryInfo &	add (const I &id, typename F::FuncType ptr)
	Add a factory to the database.
void *	get (const std::string &id, const std::string &type) const
	Retrieve the factory for the given id.
const FactoryInfo &	getInfo (const std::string &id) const
	Retrieve the FactoryInfo object for an id.
Registry &	addProperty (const std::string &id, const std::string &k, const std::string &v)
	Add a property to an already existing FactoryInfo object (via its id.).
std::set< KeyType >	loadedFactoryNames () const
	Return a list of all the known and loaded factories.
const FactoryMap &	factories () const
	Return the known factories (loading the list if not yet done).

Static Public Member Functions
static Registry &	instance ()
	Retrieve the singleton instance of Registry.

Private Member Functions
	Registry ()
	Private constructor for the singleton pattern.
	Registry (const Registry &)
	Private copy constructor for the singleton pattern.
FactoryInfo &	add (const std::string &id, void *factory, const std::string &type, const std::string &rtype, const std::string &className, const Properties &props=Properties())
	Add a factory to the database.
FactoryMap &	factories ()
	Return the known factories (loading the list if not yet done).
void	initialize ()
	Initialize the registry loading the list of factories from the .component files in the library search path.

Private Attributes
bool	m_initialized
	Flag recording if the registry has been initialized or not.
FactoryMap	m_factories
	Internal storage for factories.
std::recursive_mutex	m_mutex
	Mutex used to control concurrent access to the internal data.

Detailed Description

In-memory database of the loaded factories.

Definition at line 83 of file PluginServiceDetailsV1.h.

Member Typedef Documentation

◆ FactoryMap

typedef std::map<KeyType, FactoryInfo> Gaudi::PluginService::v1::Details::Registry::FactoryMap

Type used for the database implementation.

Definition at line 114 of file PluginServiceDetailsV1.h.

◆ KeyType

typedef std::string Gaudi::PluginService::v1::Details::Registry::KeyType

Definition at line 85 of file PluginServiceDetailsV1.h.

◆ Properties

typedef std::map<KeyType, std::string> Gaudi::PluginService::v1::Details::Registry::Properties

Type used for the properties implementation.

Definition at line 88 of file PluginServiceDetailsV1.h.

Constructor & Destructor Documentation

◆ Registry() [1/2]

Gaudi::PluginService::v2::Details::Registry::Registry ( )

private

Private constructor for the singleton pattern.

At construction time, the internal database of known factories is filled with the name of the libraries containing them, using the ".components" files in the LD_LIBRARY_PATH.

Definition at line 137 of file PluginServiceV1.cpp.

137: m_initialized( false ) {}

Gaudi::PluginService::v1::Details::Registry::m_initialized

bool m_initialized

Flag recording if the registry has been initialized or not.

Definition PluginServiceDetailsV1.h:176

◆ Registry() [2/2]

Gaudi::PluginService::v1::Details::Registry::Registry ( const Registry & )

inlineprivate

Private copy constructor for the singleton pattern.

Definition at line 159 of file PluginServiceDetailsV1.h.

159: m_initialized( false ) {}

Member Function Documentation

◆ add() [1/2]

template<typename F, typename T, typename I>

FactoryInfo & Gaudi::PluginService::v1::Details::Registry::add	(	const I &	id,
		typename F::FuncType	ptr )

inline

Add a factory to the database.

Definition at line 121 of file PluginServiceDetailsV1.h.

                                                                         {
            union {
              typename F::FuncType src;
              void*                dst;
            } p2p;
            p2p.src = ptr;
            std::ostringstream o;
            o << id;
            return add( o.str(), p2p.dst, typeid( typename F::FuncType ).name(),
                        typeid( typename F::ReturnType ).name(), demangle<T>() );
          }

◆ add() [2/2]

Registry::FactoryInfo & Gaudi::PluginService::v1::Details::Registry::add	(	const std::string &	id,
		void *	factory,
		const std::string &	type,
		const std::string &	rtype,
		const std::string &	className,
		const Properties &	props = Properties() )

private

Add a factory to the database.

Definition at line 208 of file PluginServiceV1.cpp.

                                                                        {
          auto        _guard = std::scoped_lock{ m_mutex };
          FactoryMap& facts  = factories();
          auto        entry  = facts.find( id );
          if ( entry == facts.end() ) {
            // this factory was not known yet
            entry = facts.emplace( id, FactoryInfo( "unknown", factory, type, rtype, className, props ) ).first;
          } else {
            // do not replace an existing factory with a new one
            if ( !entry->second.ptr ) entry->second.ptr = factory;
            factoryInfoSetHelper( entry->second.type, type, "type", id );
            factoryInfoSetHelper( entry->second.rtype, rtype, "return type", id );
            factoryInfoSetHelper( entry->second.className, className, "class", id );
          }
#ifdef GAUDI_REFLEX_COMPONENT_ALIASES
          // add an alias for the factory using the Reflex convention
          std::string old_name = old_style_name( id );
          if ( id != old_name )
            add( old_name, factory, type, rtype, className, props ).properties["ReflexName"] = "true";
#endif
          return entry->second;
        }

◆ addProperty()

Registry & Gaudi::PluginService::v2::Details::Registry::addProperty	(	const std::string &	id,
		const std::string &	k,
		const std::string &	v )

Add a property to an already existing FactoryInfo object (via its id.).

Definition at line 270 of file PluginServiceV1.cpp.

                                                                                                     {
          auto        _guard = std::scoped_lock{ m_mutex };
          FactoryMap& facts  = factories();
          auto        f      = facts.find( id );
          if ( f != facts.end() ) f->second.properties[k] = v;
          return *this;
        }

◆ factories() [1/2]

Registry::FactoryMap & Gaudi::PluginService::v2::Details::Registry::factories ( )

inlineprivate

Return the known factories (loading the list if not yet done).

Definition at line 166 of file PluginServiceDetailsV1.h.

                                         {
            if ( !m_initialized ) initialize();
            return m_factories;
          }

◆ factories() [2/2]

const Registry::FactoryMap & Gaudi::PluginService::v2::Details::Registry::factories ( ) const

inline

Return the known factories (loading the list if not yet done).

Definition at line 146 of file PluginServiceDetailsV1.h.

                                                     {
            if ( !m_initialized ) const_cast<Registry*>( this )->initialize();
            return m_factories;
          }

◆ get()

void * Gaudi::PluginService::v1::Details::Registry::get	(	const std::string &	id,
		const std::string &	type ) const

Retrieve the factory for the given id.

Definition at line 233 of file PluginServiceV1.cpp.

                                                                              {
          auto              _guard = std::scoped_lock{ m_mutex };
          const FactoryMap& facts  = factories();
          auto              f      = facts.find( id );
          if ( f != facts.end() ) {
#ifdef GAUDI_REFLEX_COMPONENT_ALIASES
            const Properties& props = f->second.properties;
            if ( props.find( "ReflexName" ) != props.end() )
              logger().warning( "requesting factory via old name '" + id +
                                "'"
                                "use '" +
                                f->second.className + "' instead" );
#endif
            if ( !f->second.ptr ) {
              if ( !dlopen( f->second.library.c_str(), RTLD_LAZY | RTLD_GLOBAL ) ) {
                logger().warning( "cannot load " + f->second.library + " for factory " + id );
                char* dlmsg = dlerror();
                if ( dlmsg ) logger().warning( dlmsg );
                return nullptr;
              }
              f = facts.find( id ); // ensure that the iterator is valid
            }
            if ( f->second.type == type ) return f->second.ptr;
            logger().warning( "found factory " + id + ", but of wrong type: " + demangle( f->second.type ) +
                              " instead of " + demangle( type ) );
          }
          return nullptr; // factory not found
        }

◆ getInfo()

const Registry::FactoryInfo & Gaudi::PluginService::v2::Details::Registry::getInfo ( const std::string & id ) const

Retrieve the FactoryInfo object for an id.

Definition at line 262 of file PluginServiceV1.cpp.

                                                                                {
          auto                     _guard = std::scoped_lock{ m_mutex };
          static const FactoryInfo unknown( "unknown" );
          const FactoryMap&        facts = factories();
          auto                     f     = facts.find( id );
          return ( f != facts.end() ) ? f->second : unknown;
        }

◆ initialize()

void Gaudi::PluginService::v2::Details::Registry::initialize ( )

private

Initialize the registry loading the list of factories from the .component files in the library search path.

Definition at line 139 of file PluginServiceV1.cpp.

                                  {
          auto _guard = std::scoped_lock{ m_mutex };
          if ( m_initialized ) return;
          m_initialized = true;
 
          for ( const auto& dirName : v2::Details::getPluginSearchPath() ) {
            logger().debug( std::string( " looking into " ) + dirName );
            // look for files called "*.components" in the directory
            DIR* dir = opendir( dirName.c_str() );
            if ( dir ) {
              struct dirent* entry;
              while ( ( entry = readdir( dir ) ) ) {
                std::string name( entry->d_name );
                // check if the file name ends with ".components"
                std::string::size_type extpos = name.find( ".components" );
                if ( ( extpos != std::string::npos ) && ( ( extpos + 11 ) == name.size() ) ) {
                  std::string fullPath = ( dirName + '/' + name );
                  { // check if it is a regular file
                    struct stat buf;
                    stat( fullPath.c_str(), &buf );
                    if ( !S_ISREG( buf.st_mode ) ) continue;
                  }
                  // read the file
                  logger().debug( std::string( "  reading " ) + name );
                  std::ifstream factories{ fullPath };
                  std::string   line;
                  int           factoriesCount = 0;
                  int           lineCount      = 0;
                  while ( !factories.eof() ) {
                    ++lineCount;
                    std::getline( factories, line );
                    trim( line );
                    // skip empty lines and lines starting with '#'
                    if ( line.empty() || line[0] == '#' ) continue;
                    // only accept "v1" factories
                    if ( line.substr( 0, 4 ) == "v1::" )
                      line = line.substr( 4 );
                    else
                      continue;
                    // look for the separator
                    auto pos = line.find( ':' );
                    if ( pos == std::string::npos ) {
                      logger().warning( "failed to parse line " + fullPath + ':' + std::to_string( lineCount ) );
                      continue;
                    }
                    const std::string lib( line, 0, pos );
                    const std::string fact( line, pos + 1 );
                    m_factories.emplace( fact, FactoryInfo( lib ) );
#ifdef GAUDI_REFLEX_COMPONENT_ALIASES
                    // add an alias for the factory using the Reflex convention
                    std::string old_name = old_style_name( fact );
                    if ( fact != old_name ) {
                      FactoryInfo old_info( lib );
                      old_info.properties["ReflexName"] = "true";
                      m_factories.emplace( old_name, old_info );
                    }
#endif
                    ++factoriesCount;
                  }
                  if ( logger().level() <= Logger::Debug ) {
                    logger().debug( "  found " + std::to_string( factoriesCount ) + " factories" );
                  }
                }
              }
              closedir( dir );
            }
          }
        }

◆ instance()

Registry & Gaudi::PluginService::v2::Details::Registry::instance ( )

static

Retrieve the singleton instance of Registry.

Definition at line 131 of file PluginServiceV1.cpp.

                                     {
          auto            _guard = std::scoped_lock{ ::registrySingletonMutex };
          static Registry r;
          return r;
        }

◆ loadedFactoryNames()

std::set< Registry::KeyType > Gaudi::PluginService::v2::Details::Registry::loadedFactoryNames ( ) const

Return a list of all the known and loaded factories.

Definition at line 278 of file PluginServiceV1.cpp.

                                                                   {
          auto              _guard = std::scoped_lock{ m_mutex };
          std::set<KeyType> l;
          for ( const auto& f : factories() ) {
            if ( f.second.ptr ) l.insert( f.first );
          }
          return l;
        }

Member Data Documentation

◆ m_factories

FactoryMap Gaudi::PluginService::v1::Details::Registry::m_factories

private

Internal storage for factories.

Definition at line 179 of file PluginServiceDetailsV1.h.

◆ m_initialized

bool Gaudi::PluginService::v1::Details::Registry::m_initialized

private

Flag recording if the registry has been initialized or not.

Definition at line 176 of file PluginServiceDetailsV1.h.

◆ m_mutex

std::recursive_mutex Gaudi::PluginService::v1::Details::Registry::m_mutex

mutableprivate

Mutex used to control concurrent access to the internal data.

Definition at line 182 of file PluginServiceDetailsV1.h.

The documentation for this class was generated from the following files:

GaudiPluginService/include/Gaudi/Details/PluginServiceDetailsV1.h
GaudiPluginService/src/PluginServiceV1.cpp
GaudiPluginService/src/PluginServiceV2.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FactoryMap

◆ KeyType

◆ Properties

Constructor & Destructor Documentation

◆ Registry() [1/2]

◆ Registry() [2/2]

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ addProperty()

◆ factories() [1/2]

◆ factories() [2/2]

◆ get()

◆ getInfo()

◆ initialize()

◆ instance()

◆ loadedFactoryNames()

Member Data Documentation

◆ m_factories

◆ m_initialized

◆ m_mutex