lib/cpPlugins/Interface/Interface.cxx

   1 #include <cpPlugins/Interface/Interface.h>
   2
   3 // -------------------------------------------------------------------------
   4 cpPlugins::Interface::Interface::
   5 Interface( )
   6 {
   7   this->m_Pluma.acceptProviderType< ProcessObjectProvider >( );
   8 }
   9
  10 // -------------------------------------------------------------------------
  11 cpPlugins::Interface::Interface::
  12 ~Interface( )
  13 {
  14   this->UnloadAll( );
  15 }
  16
  17 // -------------------------------------------------------------------------
  18 cpPlugins::Interface::Interface::
  19 TClasses& cpPlugins::Interface::Interface::
  20 GetClasses( )
  21 {
  22   return( this->m_Classes );
  23 }
  24
  25 // -------------------------------------------------------------------------
  26 const cpPlugins::Interface::Interface::
  27 TClasses& cpPlugins::Interface::Interface::
  28 GetClasses( ) const
  29 {
  30   return( this->m_Classes );
  31 }
  32
  33 // -------------------------------------------------------------------------
  34 cpPlugins::Interface::ProcessObject::Pointer
  35 cpPlugins::Interface::Interface::
  36 CreateObject( const std::string& name ) const
  37 {
  38   TClassesIterator cIt = this->m_Classes.find( name );
  39   if( cIt != this->m_Classes.end( ) )
  40   {
  41     ProcessObjectProvider* provider =
  42       dynamic_cast< ProcessObjectProvider* >(
  43         this->m_Providers[ cIt->second ]
  44         );
  45     if( provider != NULL )
  46     {
  47       cpPlugins::Interface::ProcessObject::Pointer po = provider->create( );
  48       po->SetName( name );
  49       return( po );
  50
  51     } // fi
  52
  53   } // fi
  54   return( NULL );
  55 }
  56
  57 // -------------------------------------------------------------------------
  58 bool cpPlugins::Interface::Interface::
  59 Load( const std::string& path )
  60 {
  61   bool ret = true;
  62   try
  63   {
  64     ret = this->m_Pluma.load( path );
  65     if( ret )
  66       this->_LoadClasses( );
  67   }
  68   catch( ... )
  69   {
  70     ret = false;
  71
  72   } // yrt
  73   return( ret );
  74 }
  75
  76 // -------------------------------------------------------------------------
  77 bool cpPlugins::Interface::Interface::
  78 Load( const std::string& folder, const std::string& name )
  79 {
  80   bool ret = true;
  81   try
  82   {
  83     ret = this->m_Pluma.load( folder, name );
  84     if( ret )
  85       this->_LoadClasses( );
  86   }
  87   catch( ... )
  88   {
  89     ret = false;
  90
  91   } // yrt
  92   return( ret );
  93 }
  94
  95 // -------------------------------------------------------------------------
  96 std::list< std::string > cpPlugins::Interface::Interface::
  97 LoadFromFolder( const std::string& folder, bool r )
  98 {
  99   std::list< std::string > files;
 100   try
 101   {
 102     files = this->m_Pluma.loadFromFolder( folder, r );
 103     if( files.size( ) > 0 )
 104       this->_LoadClasses( );
 105   }
 106   catch( ... )
 107   {
 108   } // yrt
 109   return( files );
 110 }
 111
 112 // -------------------------------------------------------------------------
 113 bool cpPlugins::Interface::Interface::
 114 Unload( const std::string& name )
 115 {
 116   bool ret = true;
 117   try
 118   {
 119     ret = this->m_Pluma.unload( name );
 120     if( ret )
 121     {
 122       this->m_Providers.clear( );
 123       this->m_Classes.clear( );
 124       this->_LoadClasses( );
 125
 126     } // fi
 127   }
 128   catch( ... )
 129   {
 130     ret = false;
 131
 132   } // yrt
 133   return( ret );
 134 }
 135
 136 // -------------------------------------------------------------------------
 137 void cpPlugins::Interface::Interface::
 138 UnloadAll( )
 139 {
 140   try
 141   {
 142     this->m_Pluma.unloadAll( );
 143   }
 144   catch( ... )
 145   {
 146     // Do nothing
 147
 148   } // yrt
 149   this->m_Providers.clear( );
 150   this->m_Classes.clear( );
 151 }
 152
 153 // -------------------------------------------------------------------------
 154 void cpPlugins::Interface::Interface::
 155 GetLoadedPlugins( std::vector< const std::string* >& names ) const
 156 {
 157   this->m_Pluma.getLoadedPlugins( names );
 158 }
 159
 160 // -------------------------------------------------------------------------
 161 bool cpPlugins::Interface::Interface::
 162 IsLoaded( const std::string& name ) const
 163 {
 164   return( this->m_Pluma.isLoaded( name ) );
 165 }
 166
 167 // -------------------------------------------------------------------------
 168 void cpPlugins::Interface::Interface::
 169 _LoadClasses( )
 170 {
 171   this->m_Providers.clear( );
 172   this->m_Classes.clear( );
 173   this->m_Pluma.getProviders( this->m_Providers );
 174
 175   // Get reader provider
 176   for( unsigned int i = 0; i < this->m_Providers.size( ); ++i )
 177   {
 178     ProcessObject::Pointer dummy = this->m_Providers[ i ]->create( );
 179     this->m_Classes[ dummy->GetClassName( ) ] = i;
 180
 181   } // rof
 182 }
 183
 184 // eof - $RCSfile$