#include <cpPlugins/Interface/Plugins.h>
#include <cpPlugins/OS/DLLManager.h>
-#include <cpPlugins/Interface/Dirent.h>
-#include <cpExtensions/Utility.h>
+#include <cpPlugins/OS/DirContents.h>
+#include <cpPlugins/Utility.h>
+
+// -------------------------------------------------------------------------
+cpPlugins::Interface::Plugins::Pointer
+cpPlugins::Interface::Plugins::m_Singleton = NULL;
// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
Pointer cpPlugins::Interface::Plugins::
New( )
{
- static Pointer singleton = NULL;
- if( singleton.IsNull( ) )
- singleton = new Self( );
- return( singleton );
+ if( Self::m_Singleton.IsNull( ) )
+ Self::m_Singleton = new Self( );
+ return( Self::m_Singleton );
}
// -------------------------------------------------------------------------
CreateAnother( ) const
{
itk::LightObject::Pointer smartPtr;
- smartPtr = NULL;
+ smartPtr = Self::m_Singleton;
return( smartPtr );
}
Pointer cpPlugins::Interface::Plugins::
Clone( ) const
{
- Pointer r = NULL;
- return( r );
-}
-
-// -------------------------------------------------------------------------
-cpPlugins::Interface::Plugins::
-TStrings cpPlugins::Interface::Plugins::
-GetLibraries( ) const
-{
- TStrings res;
- for(
- auto i = this->m_Libraries.begin( ); i != this->m_Libraries.end( ); ++i
- )
- res.insert( i->first );
- return( res );
-}
-
-// -------------------------------------------------------------------------
-cpPlugins::Interface::Plugins::
-TStrings cpPlugins::Interface::Plugins::
-GetPlugins( ) const
-{
- TStrings res;
- for( auto i = this->m_Plugins.begin( ); i != this->m_Plugins.end( ); ++i )
- res.insert( i->first );
- return( res );
+ return( Self::m_Singleton );
}
// -------------------------------------------------------------------------
-cpPlugins::Interface::Plugins::
-TStrings cpPlugins::Interface::Plugins::
-GetCategories( ) const
+const cpPlugins::Interface::Plugins::
+TFilters& cpPlugins::Interface::Plugins::
+GetFilters( ) const
{
- TStrings res;
- for( auto i = this->m_Filters.begin( ); i != this->m_Filters.end( ); ++i )
- res.insert( i->first );
- return( res );
-}
-
-// -------------------------------------------------------------------------
-cpPlugins::Interface::Plugins::
-TStrings cpPlugins::Interface::Plugins::
-GetFilters( const std::string& category ) const
-{
- TStrings res;
- auto cIt = this->m_Filters.find( category );
- if( cIt != this->m_Filters.end( ) )
- for( auto i = cIt->second.begin( ); i != cIt->second.end( ); ++i )
- res.insert( i->first );
- return( res );
+ return( this->m_Filters );
}
// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
-AddEnvironments( const std::string& new_environment )
+LoadPluginsFile( const std::string& libname )
{
- std::vector< std::string > tokens;
- cpExtensions::Tokenize( tokens, new_environment, cpPlugins_ENV_SEPARATOR );
- for( auto i = tokens.begin( ); i != tokens.end( ); ++i )
- {
- std::stringstream dir;
- dir << cpExtensions::CanonicalPath( *i );
- if( dir.str( ) != "" )
- {
- if( !cpExtensions::IsPathSeparator( dir.str( ).back( ) ) )
- dir << cpExtensions_PATH_SEPARATOR;
- std::stringstream name;
- name << dir.str( ) << cpPlugins_CONFIG;
- std::ifstream check( name.str( ).c_str( ), std::ifstream::binary );
- if( check )
- this->m_Paths.insert( dir.str( ) );
- check.close( );
-
- } // fi
-
- } // rof
+ std::map< std::string, std::set< std::string > > filters;
+ cpPlugins::OS::DLLManager::GetPluginsLibraryContents( filters, libname );
+ THandlers zero( NULL, NULL );
+ for( auto i : filters )
+ for( auto j : i.second )
+ this->m_Filters[ i.first ][ j ] = TLibData( libname, zero );
}
// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
-LoadEnvironments( )
+LoadPluginsDirectory( const std::string& dir )
{
- std::stringstream all_errors;
- for( auto d = this->m_Paths.begin( ); d != this->m_Paths.end( ); ++d )
- {
- std::stringstream name;
- name << *d << cpPlugins_CONFIG;
- std::string buffer;
- if( cpExtensions::Read( buffer, name.str( ) ) )
- {
- std::istringstream input( buffer );
- for( std::string line; std::getline( input, line ); )
- {
- std::vector< std::string > tokens;
- cpExtensions::Tokenize( tokens, line, "@" );
- std::string library_file = "";
- if( tokens[ 0 ] == "local" )
- library_file =
- cpExtensions::CanonicalPath(
- *d + std::string( cpPlugins_LIB_PREFIX ) +
- tokens[ 1 ] + std::string( cpPlugins_LIB_EXT )
- );
- else if( tokens[ 0 ] == "global" )
- library_file = tokens[ 1 ];
-
- if( library_file != "" )
- {
- std::string error = "";
- void* hnd = cpPlugins::OS::DLLManager::Load( library_file, error );
- if( hnd != NULL )
- this->m_Libraries[ library_file ] = hnd;
- else
- all_errors << " ; " << error;
-
- } // fi
-
- } // rof
+ // Create a globbing pattern
+ std::stringstream glob;
+ glob << cpPlugins_LIB_PREFIX << "*" << cpPlugins_LIB_EXT;
- } // fi
-
- } // rof
-
- // Throw errors
- if( all_errors.str( ) != "" )
- throw std::runtime_error(
- std::string( "Loading environment libraries errors: " ) +
- all_errors.str( )
- );
+ // Get possible shared libraries
+ std::set< std::string > files =
+ cpPlugins::OS::LoadDirContents( dir, false, glob.str( ) );
+ this->m_PluginsPaths.insert( dir );
+ for( auto f : files )
+ try { this->LoadPluginsFile( f ); } catch( ... ) { }
}
// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
-SaveEnvironments( const std::string& dir ) const
+GuessPlugins( )
{
- if( this->m_Paths.size( ) > 0 )
+ // Create a globbing pattern
+ std::stringstream glob;
+ glob << cpPlugins_LIB_PREFIX << "*" << cpPlugins_LIB_EXT;
+
+ // Update paths and get possible shared libraries
+ this->_ReadPluginsPathsVariable( );
+ for( auto dir : this->m_PluginsPaths )
{
- std::stringstream buffer;
- auto i = this->m_Paths.begin( );
- for( auto i = this->m_Paths.begin( ); i != this->m_Paths.end( ); ++i )
- buffer << *i << std::endl;
+ std::set< std::string > files =
+ cpPlugins::OS::LoadDirContents( dir, false, glob.str( ) );
+ for( auto f : files )
+ try { this->LoadPluginsFile( f ); } catch( ... ) { }
- std::stringstream fname;
- fname << dir;
- if( !cpExtensions::IsPathSeparator( dir.back( ) ) )
- fname << cpExtensions_PATH_SEPARATOR;
- fname << cpPlugins_PATHS;
- if( !cpExtensions::Write( buffer.str( ), fname.str( ) ) )
- throw std::runtime_error( "Error writing environment file." );
- }
- else
- throw std::runtime_error( "No paths to save." );
+ } // rof
}
// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
-OpenEnvironments( const std::string& dir )
+GuessEnvironment( const std::string& dir )
{
std::stringstream fname;
- fname << dir;
- if( !cpExtensions::IsPathSeparator( dir.back( ) ) )
- fname << cpExtensions_PATH_SEPARATOR;
- fname << cpPlugins_PATHS;
+ fname << dir << cpPlugins_PATH_SEPARATOR << cpPlugins_PATHS;
std::string buffer;
- if( cpExtensions::Read( buffer, fname.str( ) ) )
+ if( cpPlugins::Read( buffer, fname.str( ) ) )
{
std::istringstream input( buffer );
- std::stringstream paths;
for( std::string line; std::getline( input, line ); )
- paths << line << cpPlugins_ENV_SEPARATOR;
- this->AddEnvironments( paths.str( ) );
- }
- else
- throw std::runtime_error( "Error opening environment file." );
-}
-
-// -------------------------------------------------------------------------
-void cpPlugins::Interface::Plugins::
-LoadFile( const std::string& fname )
-{
- // Resolve canonical filename
- std::string can_name = cpExtensions::CanonicalPath( fname );
- if( can_name == "" )
- throw std::runtime_error(
- std::string( "Loading file: can't find library \"" ) +
- fname +
- std::string( "\"" )
- );
- if( this->m_Plugins.find( can_name ) != this->m_Plugins.end( ) )
- return;
-
- // Load the library
- std::string error = "";
- void* hnd = cpPlugins::OS::DLLManager::Load( can_name, error );
- if( hnd == NULL )
- throw std::runtime_error(
- std::string( "Loading plugin library: " ) + error
- );
-
- // Get plugins name
- typedef const char* ( *_TFunction )( );
- _TFunction plugins_name_function = ( _TFunction )(
- cpPlugins::OS::DLLManager::GetFunctionHandle( hnd, "cpPlugins_Name" )
- );
- if( plugins_name_function == NULL )
- {
- cpPlugins::OS::DLLManager::UnLoad( hnd );
- throw std::runtime_error(
- std::string( "Library \"" ) +
- can_name +
- std::string( "\" not recognized as a cpPlugins library" )
- );
+ this->m_PluginsPaths.insert( cpPlugins::CanonicalPath( line ) );
} // fi
- std::string plugins_name = plugins_name_function( );
-
- // Get loaded filters
- _TFunction function = ( _TFunction )(
- cpPlugins::OS::DLLManager::GetFunctionHandle( hnd, "cpPlugins_LoadedFilters" )
- );
- if( function == NULL )
- {
- cpPlugins::OS::DLLManager::UnLoad( hnd );
- throw std::runtime_error(
- std::string( "Library \"" ) +
- can_name +
- std::string( "\" not recognized as a cpPlugins library" )
- );
-
- } // fi
- std::string descriptors = function( );
- std::replace( descriptors.begin( ), descriptors.end( ), ';', ' ' );
- std::istringstream str( descriptors );
- TFilters filters;
- while( str )
- {
- std::string value, category, name;
- str >> value;
- if( value == "" )
- continue;
- std::replace( value.begin( ), value.end( ), ':', ' ' );
- std::istringstream value_str( value );
- value_str >> category >> name;
-
- // Check if the filter has been already loaded
- bool found = false;
- auto fIt = this->m_Filters.find( category );
- if( fIt != this->m_Filters.end( ) )
- found = fIt->second.find( name ) != fIt->second.end( );
- if( found )
- {
- cpPlugins::OS::DLLManager::UnLoad( hnd );
- throw std::runtime_error(
- std::string( "Filter \"" ) +
- category + std::string( "::" ) + name +
- std::string( "\" already exists." )
- );
-
- } // fi
-
- // Get filter creator
- TCreator creator = ( TCreator )(
- cpPlugins::OS::DLLManager::GetFunctionHandle( hnd, category + "_" + name )
- );
- if( creator == NULL )
- {
- cpPlugins::OS::DLLManager::UnLoad( hnd );
- throw std::runtime_error(
- std::string( "Filter \"" ) +
- category + std::string( "::" ) + name +
- std::string( "\" does not have a valid creator." )
- );
-
- } // fi
-
- TCreatorData data;
- data.PluginName = plugins_name;
- data.LibraryHandle = hnd;
- data.Creator = creator;
- filters[ category ][ name ] = data;
-
- } // elihw
-
- // Keep track of all loaded handlers
- for( auto cIt = filters.begin( ); cIt != filters.end( ); ++cIt )
- for( auto nIt = cIt->second.begin( ); nIt != cIt->second.end( ); ++nIt )
- this->m_Filters[ cIt->first ][ nIt->first ] = nIt->second;
- this->m_Plugins[ can_name ] = hnd;
}
// -------------------------------------------------------------------------
-void cpPlugins::Interface::Plugins::
-LoadPlugin( const std::string& pname )
+bool cpPlugins::Interface::Plugins::
+SaveEnvironment( const std::string& dir )
{
+ std::stringstream buffer;
+ for( auto p : this->m_PluginsPaths )
+ buffer << p << std::endl;
std::stringstream fname;
- fname << cpPlugins_LIB_PREFIX << pname << cpPlugins_LIB_EXT;
- unsigned int count = 0;
- for( auto i = this->m_Paths.begin( ); i != this->m_Paths.end( ); ++i )
- {
- std::stringstream dir;
- dir << *i;
- if( !cpExtensions::IsPathSeparator( i->back( ) ) )
- dir << cpExtensions_PATH_SEPARATOR;
- dir << fname.str( );
- try
- {
- this->LoadFile( dir.str( ) );
- }
- catch( ... )
- {
- count++;
-
- } // yrt
-
- } // rof
-
- // Throw error, if any
- if( count == this->m_Paths.size( ) )
- throw std::runtime_error(
- std::string( "Could not load plugin " ) +
- std::string( "\"" ) + pname +
- std::string( "\" from any registered path." )
- );
+ fname << dir << cpPlugins_PATH_SEPARATOR << cpPlugins_PATHS;
+ return( cpPlugins::Write( buffer.str( ), fname.str( ) ) );
}
// -------------------------------------------------------------------------
-void cpPlugins::Interface::Plugins::
-LoadDirectory( const std::string& dirname )
+cpPlugins::BaseObjects::ProcessObject::Pointer
+cpPlugins::Interface::Plugins::
+CreateFilter( const std::string& category, const std::string& name )
{
- DIR* dir;
- struct dirent* ent;
- if( ( dir = opendir( dirname.c_str( ) ) ) != NULL )
+ typedef void* ( *_TCreator )( );
+ typedef cpPlugins::BaseObjects::ProcessObject::Pointer _TPtr;
+ _TPtr o = NULL;
+ auto cat = this->m_Filters.find( category );
+ if( cat != this->m_Filters.end( ) )
{
- while( ( ent = readdir( dir ) ) != NULL )
+ auto nam = cat->second.find( name );
+ if( nam != cat->second.end( ) )
{
- try
+ void* l_hnd = nam->second.second.first;
+ void* f_hnd = nam->second.second.second;
+ if( l_hnd == NULL )
{
- std::stringstream fname;
- fname << dirname << cpExtensions_PATH_SEPARATOR << ent->d_name;
- this->LoadFile( fname.str( ) );
- }
- catch( ... ) { }
+ l_hnd = cpPlugins::OS::DLLManager::LoadPlugins( nam->second.first );
+ nam->second.second.first = l_hnd;
- } // elihw
- closedir( dir );
- }
- else
- throw std::runtime_error(
- std::string( "Could not load directory " ) +
- std::string( "\"" ) + dirname + std::string( "\"" )
- );
-}
-
-// -------------------------------------------------------------------------
-void cpPlugins::Interface::Plugins::
-GuessPlugins( )
-{
- for( auto i = this->m_Paths.begin( ); i != this->m_Paths.end( ); ++i )
- {
- try { this->LoadDirectory( *i ); }
- catch( ... ) { }
+ } // fi
+ if( f_hnd == NULL )
+ {
+ f_hnd =
+ cpPlugins::OS::DLLManager::LoadCreator( l_hnd, category, name );
+ nam->second.second.second = f_hnd;
- } // rof
-}
+ } // fi
+ _TCreator creator = reinterpret_cast< _TCreator >( f_hnd );
+ if( creator != NULL )
+ {
+ void* a = creator( );
+ o = reinterpret_cast< _TPtr* >( a )->GetPointer( );
+ o->SetName( name );
+ o->SetPluginName( nam->second.first );
-// -------------------------------------------------------------------------
-cpPlugins::Interface::Plugins::TProcess::Pointer
-cpPlugins::Interface::Plugins::
-CreateProcessObject( const std::string& category, const std::string& name )
-{
- typedef cpPlugins::BaseObjects::ProcessObject::Pointer _Ptr;
- _Ptr o = NULL;
- auto cIt = this->m_Filters.find( category );
- if( cIt != this->m_Filters.end( ) )
- {
- auto nIt = cIt->second.find( name );
- if( nIt != cIt->second.end( ) )
- {
- o = reinterpret_cast< _Ptr* >( nIt->second.Creator( ) )->GetPointer( );
- o->SetName( name );
- o->SetPluginName( nIt->second.PluginName );
+ } // fi
} // fi
} // fi
+ if( o.IsNull( ) )
+ throw std::runtime_error(
+ std::string( "Could not create a valid ProcessObject of type \"" ) +
+ category + std::string( ":" ) +
+ name + std::string( "\"" )
+ );
return( o );
}
Plugins( )
: Superclass( )
{
- char* p = std::getenv( cpPlugins_PATHS );
- std::stringstream str;
- if( p != NULL )
- str << p << cpPlugins_ENV_SEPARATOR;
- str << ".";
- this->AddEnvironments( str.str( ) );
-
- // Try to read locally defined paths
- std::vector< std::string > tokens;
- cpExtensions::Tokenize( tokens, str.str( ), cpPlugins_ENV_SEPARATOR );
- for( auto t = tokens.begin( ); t != tokens.end( ); ++t )
- this->OpenEnvironments( *t );
+ cpPlugins::OS::DLLManager::TeaseLoadedLibraries( );
}
// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
PrintSelf( std::ostream& os, itk::Indent indent ) const
{
- // Show data
- os << indent << "----- PATHS -----" << std::endl;
- auto paths = this->GetPaths( );
- for( auto paIt = paths.begin( ); paIt != paths.end( ); ++paIt )
- os << indent << *paIt << std::endl;
- os << indent << std::endl << indent << "----- PLUGINS -----" << std::endl;
- auto plugins = this->GetPlugins( );
- for( auto plIt = plugins.begin( ); plIt != plugins.end( ); ++plIt )
- os << indent << *plIt << std::endl;
- os << indent << std::endl << indent << "----- FILTERS -----" << std::endl;
- auto categories = this->GetCategories( );
- for( auto cIt = categories.begin( ); cIt != categories.end( ); ++cIt )
+ for( auto i : this->m_Filters )
{
- os << indent << "** Category: " << *cIt << " **" << std::endl;
- auto filters = this->GetFilters( *cIt );
- for( auto fIt = filters.begin( ); fIt != filters.end( ); ++fIt )
- os << indent << indent << indent << "Filter: " << *fIt << std::endl;
+ os << indent << "+ " << i.first << std::endl;
+ for( auto j : i.second )
+ os << indent << "|----> " << j.first << std::endl;
} // rof
+}
+// -------------------------------------------------------------------------
+void cpPlugins::Interface::Plugins::
+_ReadPluginsPathsVariable( )
+{
+#ifdef cpPlugins_OS_Windows
+ char* p;
+ size_t size;
+ _dupenv_s( &p, &size, cpPlugins_PATHS );
+#else // cpPlugins_OS_Windows
+ char* p = std::getenv( cpPlugins_PATHS );
+#endif // cpPlugins_OS_Windows
+ std::stringstream str;
+ if( p != NULL )
+ str << p << cpPlugins_ENV_SEPARATOR;
+ str << ".";
+ std::vector< std::string > tokens;
+ cpPlugins::Tokenize( tokens, str.str( ), cpPlugins_ENV_SEPARATOR );
+ for( auto dir : tokens )
+ this->m_PluginsPaths.insert( cpPlugins::CanonicalPath( dir ) );
}
// eof - $RCSfile$
git://git.creatis.insa-lyon.fr / cpPlugins.git / blobdiff