YACS::ENGINE::LocalContainer Class Reference

#include <CppContainer.hxx>

Collaboration diagram for YACS::ENGINE::LocalContainer:

Public Member Functions
void	destroy ()
LocalLibrary	loadComponentLibrary (const std::string &, const char *prefix=NULL, bool forcedLoad=false)
CppComponent *	createComponentInstance (const char *componentName)
	Find or create a new C++ component instance. More...
void	createInternalInstance (const char *componentName, void *&obj, RunFunction &r, TerminateFunction &t)
void	unLoadComponentLibrary (const std::string &aCompName)
void	unregisterComponentInstance (CppComponent *C)

Static Public Member Functions
static YACS::ENGINE::LocalContainer *	get ()

Protected Member Functions
	LocalContainer ()
virtual	~LocalContainer ()

Protected Attributes
YACS::BASES::Mutex	_instance_mapMutex
YACS::BASES::Mutex	_library_mapMutex

Static Protected Attributes
static std::map< std::string, LocalLibrary >	_library_map
static std::multimap< std::string, CppComponent * >	_instance_map

Static Private Attributes
static LocalContainer *	_singleton = NULL

Friends
class	CppComponent

Detailed Description

Definition at line 71 of file CppContainer.hxx.

Constructor & Destructor Documentation

LocalContainer()

LocalContainer::LocalContainer ( )

protected

Definition at line 182 of file CppContainer.cxx.

{
}

Referenced by get().

~LocalContainer()

LocalContainer::~LocalContainer ( )

protectedvirtual

Definition at line 186 of file CppContainer.cxx.

{
    destroy();
}

References destroy().

Member Function Documentation

createComponentInstance()

CppComponent * LocalContainer::createComponentInstance

(

const char *

name

)

Find or create a new C++ component instance.

Create a new component class (C++ implementation)

Parameters

name	: component name

Try to return a handle to an new instance of a C++ component If the associated library is not loaded, try to load it

Returns

a handle to the component instance or throw an exception if it's not possible

Definition at line 243 of file CppContainer.cxx.

{
  void *o;
  RunFunction r;
  TerminateFunction t;
  
  createInternalInstance(name, o, r, t);
  
  CppComponent * C;
  C = new CppComponent(o, r, t, name);
  _instance_mapMutex.lock(); // lock to be alone 
  _instance_map.insert(std::pair<std::string, CppComponent *>(name, C));
  _instance_mapMutex.unLock(); // unlock
  return C;
}

References _instance_map, _instance_mapMutex, CppComponent, createInternalInstance(), testCppPluginInvokation::r, and gui.Appli::t.

Referenced by YACS::ENGINE::CppContainer::createComponentInstance().

createInternalInstance()

void LocalContainer::createInternalInstance	(	const char *	componentName,
		void *&	obj,
		RunFunction &	r,
		TerminateFunction &	t
	)

Definition at line 259 of file CppContainer.cxx.

{
  LocalLibrary L;
 
  std::map<std::string, LocalLibrary>::iterator foundL = _library_map.find(name);
  if (foundL != _library_map.end())
    L = foundL->second;
  else
    L = loadComponentLibrary(name, NULL, false);
  
  r = L.runHandle;
  InitFunction i = L.initHandle;
  t = L.terminateHandle;
  
  PingFunction p = L.pingHandle;
  if (p) p();
  
  obj = i();
  
}

References _library_map, yacsorb.CORBAEngineTest::i, YACS::ENGINE::LocalLibrary::initHandle, loadComponentLibrary(), p, YACS::ENGINE::LocalLibrary::pingHandle, testCppPluginInvokation::r, YACS::ENGINE::LocalLibrary::runHandle, gui.Appli::t, and YACS::ENGINE::LocalLibrary::terminateHandle.

Referenced by createComponentInstance(), and YACS::ENGINE::CppContainer::createInternalInstance().

destroy()

void LocalContainer::destroy

(

)

Definition at line 200 of file CppContainer.cxx.

{
  if (NULL == _singleton)
    return;
 
  // destroy all component instances
  _instance_mapMutex.lock(); // lock
  std::multimap<std::string, CppComponent *>::iterator iI, iJ;
  for (iI=_instance_map.begin(); iI != _instance_map.end(); iI = iJ)
    {
      iJ = iI++;
      iI->second->setContainer(NULL);
      delete iI->second;
    }
  _instance_map.clear();
  _instance_mapMutex.unLock(); // unlock
 
  // unload all dynamic libraries
  _library_mapMutex.lock();
  std::map<std::string, LocalLibrary>::iterator iL;
  for (iL=_library_map.begin(); iL != _library_map.end(); iL++)
    dlclose(iL->second.handle);
  _library_map.clear();
  _library_mapMutex.unLock();
 
  delete _singleton;
  _singleton = NULL;
}

References _instance_map, _instance_mapMutex, _library_map, _library_mapMutex, and _singleton.

Referenced by ~LocalContainer().

get()

LocalContainer * LocalContainer::get ( )

static

Definition at line 191 of file CppContainer.cxx.

{
    if (NULL == _singleton) 
    {
        _singleton = new LocalContainer;
    }
    return _singleton;
}

References _singleton, and LocalContainer().

Referenced by YACS::ENGINE::CppContainer::start().

loadComponentLibrary()

LocalLibrary LocalContainer::loadComponentLibrary	(	const std::string &	aCompName,
		const char *	prefix = NULL,
		bool	forcedLoad = false
	)

Definition at line 293 of file CppContainer.cxx.

{
 
  // if forcedLoad is true, unload library if it exists
  // if forcedLoad is false, return the existing library or load it
  
  if (forcedLoad)
      unLoadComponentLibrary(aCompName);
  else 
    {
      std::map<std::string, LocalLibrary >::iterator itLib 
           = _library_map.find(aCompName);
      if (itLib !=  _library_map.end()) return itLib->second;
    }
    
  // --- try dlopen C++ component
 
  std::string sprefix;
  if (prefix)
    sprefix = prefix;
  else 
    {
      std::string s = aCompName + "_ROOT_DIR";
      toupper(s);
      const char * t = getenv(s.c_str());
      sprefix="";
      if (t) 
        {
          sprefix = t;
          sprefix += "/lib/salome";
        }
    }
  
#ifndef WIN32
#ifdef __APPLE__
  std::string impl_name = std::string ("lib") + aCompName + std::string("Local.dylib");
#else
  std::string impl_name = std::string ("lib") + aCompName + std::string("Local.so");
#endif
  if(sprefix != "")
    impl_name = sprefix + std::string("/") + impl_name;
#else
  std::string impl_name = aCompName + std::string("Local.dll");
  impl_name = sprefix + std::string("\\") + impl_name;
#endif
  DEBTRACE("impl_name = " << impl_name);
    
#if defined( WIN32 )
  HMODULE handle;
#if defined(UNICODE)
  size_t length = strlen(impl_name.c_str()) + sizeof(char);
  wchar_t* aPath = new wchar_t[length + 1];
  memset(aPath, '\0', length);
  mbstowcs(aPath, impl_name.c_str(), length);
#else
  const char* aPath = fullLibName.c_str();
#endif
  handle = dlopen( aPath ) ;
#else
  void* handle;
  handle = dlopen( impl_name.c_str() , RTLD_LAZY ) ;
#endif
 
  const char * sError;
#if defined( WIN32 )
  sError = "Not available here !";
#endif
  
#if defined( WIN32 )
  if (!handle) 
#else
  sError = dlerror();
  if ((sError = dlerror()) || !handle) 
#endif
    {
      std::stringstream msg;
      msg << "Can't load shared library : " << impl_name
          << " (dlopen error : " << sError << ") at "
          << __FILE__ << ":" << __LINE__;
      throw YACS::Exception(msg.str());
    }
  
  void *ihandle, *rhandle, *phandle = NULL, *thandle = NULL;
      
  ihandle = dlsym(handle, "__init");
#if defined( WIN32 )
  if (!ihandle)
#else
  if (sError = dlerror()) 
#endif
    {
      dlclose(handle);
      std::stringstream msg;
      msg << "Library " << impl_name
          << " doesn't contains initialization function (" << sError << ") at "
          << __FILE__ << ":" << __LINE__;
      throw YACS::Exception(msg.str());
    }
  
  rhandle = dlsym(handle, "__run");
#if defined( WIN32 )
  if (!rhandle)
#else
  if (sError = dlerror()) 
#endif
    {
      dlclose(handle);
      std::stringstream msg;
      msg << "Library " << impl_name
          << " doesn't contains main switch function (" << sError << ") at "
          << __FILE__ << ":" << __LINE__;
      throw YACS::Exception(msg.str());
    }
      
  thandle = dlsym(handle, "__terminate");
#if defined( WIN32 )
  if (!thandle)
#else
  if (sError = dlerror()) 
#endif
    {
      dlclose(handle);
      std::stringstream msg;
      msg << "Library " << impl_name
          << " doesn't contains terminate function (" << sError << ") at "
          << __FILE__ << ":" << __LINE__;
      throw YACS::Exception(msg.str());
    }
  phandle = dlsym(handle, "__ping");
      
  _library_map[aCompName] = LocalLibrary(handle, (InitFunction) ihandle, 
                                                 (RunFunction)  rhandle, 
                                                 (PingFunction) phandle,
                                                 (TerminateFunction) thandle);
  return _library_map[aCompName];
}

References _library_map, DEBTRACE, gui.Appli::t, toupper(), and unLoadComponentLibrary().

Referenced by createInternalInstance(), and YACS::ENGINE::CppContainer::loadComponentLibrary().

unLoadComponentLibrary()

void LocalContainer::unLoadComponentLibrary

(

const std::string &

aCompName

)

Definition at line 430 of file CppContainer.cxx.

{
  std::map<std::string, LocalLibrary >::iterator itLib 
           = _library_map.find(aCompName);
  
  if (itLib ==  _library_map.end()) return;
  
  dlclose(itLib->second.handle);
  _library_map.erase(itLib);
 
}

References _library_map.

Referenced by loadComponentLibrary().

unregisterComponentInstance()

void LocalContainer::unregisterComponentInstance

(

CppComponent *

C

)

Definition at line 281 of file CppContainer.cxx.

{
  _instance_mapMutex.lock(); // lock to be alone
  _instance_map.erase(C->getCompoName());
  _instance_mapMutex.unLock(); // unlock
}

References _instance_map, _instance_mapMutex, and YACS::ENGINE::ComponentInstance::getCompoName().

Referenced by YACS::ENGINE::CppContainer::unregisterComponentInstance().

Friends And Related Function Documentation

CppComponent

friend class CppComponent

friend

Definition at line 73 of file CppContainer.hxx.

Referenced by createComponentInstance().

Member Data Documentation

_instance_map

std::multimap< std::string, CppComponent * > LocalContainer::_instance_map

staticprotected

Definition at line 94 of file CppContainer.hxx.

Referenced by createComponentInstance(), destroy(), and unregisterComponentInstance().

_instance_mapMutex

YACS::BASES::Mutex YACS::ENGINE::LocalContainer::_instance_mapMutex

protected

Definition at line 92 of file CppContainer.hxx.

Referenced by createComponentInstance(), destroy(), and unregisterComponentInstance().

_library_map

std::map< std::string, LocalLibrary > LocalContainer::_library_map

staticprotected

Definition at line 93 of file CppContainer.hxx.

Referenced by createInternalInstance(), destroy(), loadComponentLibrary(), and unLoadComponentLibrary().

_library_mapMutex

YACS::BASES::Mutex YACS::ENGINE::LocalContainer::_library_mapMutex

protected

Definition at line 92 of file CppContainer.hxx.

Referenced by destroy().

_singleton

LocalContainer * LocalContainer::_singleton = NULL

staticprivate

Definition at line 98 of file CppContainer.hxx.

Referenced by destroy(), and get().

---

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

• src/runtime/CppContainer.hxx
• src/runtime/CppContainer.cxx