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< ObjectProvider >( );
   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::Object::Pointer cpPlugins::Interface::Interface::
  35 CreateObject( const std::string& name ) const
  36 {
  37   TClassesIterator cIt = this->m_Classes.find( name );
  38   if( cIt != this->m_Classes.end( ) )
  39   {
  40     ObjectProvider* provider =
  41       dynamic_cast< ObjectProvider* >( this->m_Providers[ cIt->second ] );
  42     if( provider != NULL )
  43       return( provider->create( ) );
  44
  45   } // fi
  46   return( NULL );
  47 }
  48
  49 // -------------------------------------------------------------------------
  50 cpPlugins::Interface::ProcessObject::Pointer
  51 cpPlugins::Interface::Interface::
  52 CreateProcessObject( const std::string& name ) const
  53 {
  54   cpPlugins::Interface::Object::Pointer o = this->CreateObject( name );
  55   cpPlugins::Interface::ProcessObject::Pointer p =
  56     dynamic_cast< cpPlugins::Interface::ProcessObject* >( o.GetPointer( ) );
  57   return( p );
  58 }
  59
  60 // -------------------------------------------------------------------------
  61 bool cpPlugins::Interface::Interface::
  62 Load( const std::string& path )
  63 {
  64   bool ret = true;
  65   try
  66   {
  67     ret = this->m_Pluma.load( path );
  68     if( ret )
  69       this->_LoadClasses( );
  70   }
  71   catch( ... )
  72   {
  73     ret = false;
  74
  75   } // yrt
  76   return( ret );
  77 }
  78
  79 // -------------------------------------------------------------------------
  80 bool cpPlugins::Interface::Interface::
  81 Load( const std::string& folder, const std::string& name )
  82 {
  83   bool ret = true;
  84   try
  85   {
  86     ret = this->m_Pluma.load( folder, name );
  87     if( ret )
  88       this->_LoadClasses( );
  89   }
  90   catch( ... )
  91   {
  92     ret = false;
  93
  94   } // yrt
  95   return( ret );
  96 }
  97
  98 // -------------------------------------------------------------------------
  99 int cpPlugins::Interface::Interface::
 100 LoadFromFolder( const std::string& folder, bool r )
 101 {
 102   bool ret = true;
 103   try
 104   {
 105     ret = this->m_Pluma.loadFromFolder( folder, r );
 106     if( ret )
 107       this->_LoadClasses( );
 108   }
 109   catch( ... )
 110   {
 111     ret = false;
 112
 113   } // yrt
 114   return( ret );
 115 }
 116
 117 // -------------------------------------------------------------------------
 118 bool cpPlugins::Interface::Interface::
 119 Unload( const std::string& name )
 120 {
 121   bool ret = true;
 122   try
 123   {
 124     ret = this->m_Pluma.unload( name );
 125     if( ret )
 126     {
 127       this->m_Providers.clear( );
 128       this->m_Classes.clear( );
 129       this->_LoadClasses( );
 130
 131     } // fi
 132   }
 133   catch( ... )
 134   {
 135     ret = false;
 136
 137   } // yrt
 138   return( ret );
 139 }
 140
 141 // -------------------------------------------------------------------------
 142 void cpPlugins::Interface::Interface::
 143 UnloadAll( )
 144 {
 145   try
 146   {
 147     this->m_Pluma.unloadAll( );
 148   }
 149   catch( ... )
 150   {
 151     // Do nothing
 152
 153   } // yrt
 154   this->m_Providers.clear( );
 155   this->m_Classes.clear( );
 156 }
 157
 158 // -------------------------------------------------------------------------
 159 void cpPlugins::Interface::Interface::
 160 GetLoadedPlugins( std::vector< const std::string* >& names ) const
 161 {
 162   this->m_Pluma.getLoadedPlugins( names );
 163 }
 164
 165 // -------------------------------------------------------------------------
 166 bool cpPlugins::Interface::Interface::
 167 IsLoaded( const std::string& name ) const
 168 {
 169   return( this->m_Pluma.isLoaded( name ) );
 170 }
 171
 172 // -------------------------------------------------------------------------
 173 void cpPlugins::Interface::Interface::
 174 _LoadClasses( )
 175 {
 176   this->m_Providers.clear( );
 177   this->m_Classes.clear( );
 178   this->m_Pluma.getProviders( this->m_Providers );
 179
 180   // Get reader provider
 181   for( unsigned int i = 0; i < this->m_Providers.size( ); ++i )
 182   {
 183     Object::Pointer dummy = this->m_Providers[ i ]->create( );
 184     this->m_Classes[ dummy->GetClassName( ) ] = i;
 185
 186   } // rof
 187 }
 188
 189 // eof - $RCSfile$