-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
#include "SALOME_NamingService.hxx"
#include "ServiceUnreachable.hxx"
+#include "OpUtil.hxx"
#include "utilities.h"
*
* After Default Constructor, one needs to initialize ORB.
* \sa init_orb(CORBA::ORB_ptr orb), SALOME_NamingService(CORBA::ORB_ptr orb)
- */
+ */
// ============================================================================
SALOME_NamingService::SALOME_NamingService()
}
// ============================================================================
-/*! \brief Standard Constructor, with ORB reference.
- *
+/*! \brief Standard Constructor, with ORB reference.
+ *
* Initializes the naming service root context
* \param orb CORBA::ORB_ptr arguments
- */
+ */
// ============================================================================
SALOME_NamingService::SALOME_NamingService(CORBA::ORB_ptr orb)
_initialize_root_context();
}
+SALOME_NamingService_Abstract *SALOME_NamingService::clone()
+{
+ return new SALOME_NamingService(_orb);
+}
+
// ============================================================================
/*! \brief Standard destructor.
*
* The standard destructor does nothing special.
- */
+ */
// ============================================================================
SALOME_NamingService::~SALOME_NamingService()
//MESSAGE("SALOME_NamingService destruction");
}
+std::vector< std::string > SALOME_NamingService::repr()
+{
+ return std::vector< std::string >();
+}
+
// ============================================================================
/*! \brief initializes ORB reference and naming service root context.
- *
+ *
* Initializes ORB reference and naming service root context.
* For use after default constructor.
* If param orb is null, the orb is initialized
* \param orb CORBA::ORB_ptr arguments
- */
+ */
// ============================================================================
void SALOME_NamingService::init_orb(CORBA::ORB_ptr orb)
if(orb)
_orb = CORBA::ORB::_duplicate(orb);
else
- {
- int argc=0;
- _orb = CORBA::ORB_init(argc, 0); // Here we make the assumption that the orb has already been initialized
- }
+ _orb = KERNEL::GetRefToORB(); // Here we make the assumption that the orb has already been initialized
_initialize_root_context();
}
* as an absolute pathname. Else, pathname is taken as a relative
* path, to current context. Prefer absolute pathname, relative
* pathname are not safe, when SALOME_NamingService object is
- * shared or use in multithreaded context.
+ * shared or use in multithreaded context.
* If the path ends with '/', only a directory is created.
* \sa Change_Directory(const char* Path),
* Create_Directory(const char* Path)
* CORBA::Object_ptr Resolve(const char* Path)
- */
+ */
// ============================================================================
void SALOME_NamingService::Register(CORBA::Object_ptr ObjRef,
const char* Path)
- throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
// A directory is treated (not only an object name)
// test if the directory where ObjRef should be recorded already exists
// If not, create the new context
-
+
try{
CORBA::Object_var obj = _current_context->resolve(context_name);
_current_context = CosNaming::NamingContext::_narrow(obj);
// --- The current directory is now the directory where the object should
// be recorded
- int sizePath = splitPath.size();
- if (sizePath > dimension_resultat){
- ASSERT(sizePath == dimension_resultat+1);
+ size_t sizePath = splitPath.size();
+ if (sizePath > (size_t)dimension_resultat){
+ ASSERT(sizePath == (size_t)dimension_resultat+1);
context_name.length(1);
try{
// ============================================================================
/*! \brief get the CORBA object reference associated to a name.
- *
+ *
* get the CORBA object reference associated to a complete name with a path.
- * If the NamingService is out, the exception ServiceUnreachable is thrown
+ * If the NamingService is out, the exception ServiceUnreachable is thrown
* \param Path pathname. If the pathname begins with a '/', pathname is taken
* as an absolute pathname. Else, pathname is taken as a relative
* path, to current context. Prefer absolute pathname, relative
* or nil reference in other cases.
* \sa Register(CORBA::Object_ptr ObjRef, const char* Path),
* Change_Directory(const char* Path)
- */
+ */
// ============================================================================
CORBA::Object_ptr SALOME_NamingService::Resolve(const char* Path)
- throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
}
// ============================================================================
-/*! \brief get the CORBA object reference associated to an uncomplete name.
+/*! \brief get the CORBA object reference associated to an incomplete name.
*
- * get the CORBA object reference associated to an uncomplete name with a
+ * get the CORBA object reference associated to an incomplete name with a
* path. Look for the first occurrence of name*.
- * If the NamingService is out, the exception ServiceUnreachable is thrown
+ * If the NamingService is out, the exception ServiceUnreachable is thrown
* \param Path pathname under the form "/path/name" (Absolute reference !)
* search the fist reference like "/path(.dir)/name*(.kind)"
* \return the object reference if found, or nil reference.
// ============================================================================
CORBA::Object_ptr SALOME_NamingService::ResolveFirst(const char* Path)
- throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
isOk =true;
else
isOk = Change_Directory(basePath.c_str());
-
+
if (isOk)
{
std::vector<std::string> listElem = list_directory();
std::vector<std::string>::iterator its = listElem.begin();
-
+
while (its != listElem.end())
{
if ((*its).find(name) == 0)
{
return Resolve((*its).c_str());
}
-
+
its++;
}
}
* \param hostname name of the machine on which the component is searched.
* \param containerName name of the container in which the component is
instantiated.
- * \param componentName name of the component we are looking for an existing
+ * \param componentName name of the component we are looking for an existing
instance.
* \param nbproc in case of multi processor machine, container name is
* suffixed with _nbproc.
* \return the object reference
- */
+ */
// ============================================================================
CORBA::Object_ptr
const char* containerName,
const char* componentName,
const int nbproc)
- throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
if ( nbproc >= 1 )
{
- char *str_nbproc = new char[8];
+ char *str_nbproc = new char[16];
sprintf(str_nbproc, "_%d", nbproc);
if( strstr(name.c_str(),str_nbproc) == NULL)
continue; // check only containers with _%d in name
}
}
-// ============================================================================
-/*! \brief provide a default container name if empty.
- *
- * the given container name is returned unchanged, unless it is empty.
- * \param containerName
- * \return container name, where empty input is replaced by "FactoryServer",
- * without the path.
- * \sa BuildContainerNameForNS(const char *containerName, const char *hostname)
- */
-// ============================================================================
-
-std::string SALOME_NamingService::ContainerName(const char *containerName)
-{
- std::string ret,containerNameCpp(containerName);
-
- if (containerNameCpp.empty())
- ret = "FactoryServer";
- else
- ret = containerName;
-
- return ret;
-}
-
-// ============================================================================
-/*! \brief build a container name, given a ContainerParameters struct.
- *
- * Build a container name with a ContainerParameters struct. In case of multi
- * processor machine, container name is suffixed with number of processors.
- * \param params struct from which we get container name (may be empty) and
- * number of processors.
- * \return a container name without the path.
- * \sa BuildContainerNameForNS(const Engines::ContainerParameters& params,
- * const char *hostname)
- */
-// ============================================================================
-
-std::string SALOME_NamingService::ContainerName(const Engines::ContainerParameters& params)
-{
- int nbproc;
-
- if ( !params.isMPI )
- nbproc = 0;
- else if ( params.nb_proc <= 0 )
- nbproc = 1;
- else
- nbproc = params.nb_proc;
-
- std::string ret(ContainerName(params.container_name));
-
- if ( nbproc >= 1 )
- {
- std::ostringstream suffix;
- suffix << "_" << nbproc;
- ret += suffix.str();
- }
-
- return ret;
-}
-
-// ============================================================================
-/*! \brief build a string representing a container in Naming Service.
- *
- * Build a string representing the absolute pathname of a container in
- * SALOME_NamingService. This form gives a suffixed containerName in case of
- * multi processor machine.
- * \param containerName name of the container in which the component is
- instantiated.
- * \param hostname name of the host of the container, without domain names.
- * \return the path under the form /Containers/hostname/containerName
- * \sa ContainerName(const Engines::MachineParameters& params)
- */
-// ============================================================================
-
-std::string SALOME_NamingService::BuildContainerNameForNS(const char *containerName, const char *hostname)
-{
- std::string ret("/Containers/");
- ret += hostname;
- ret += "/";
- ret += ContainerName(containerName);
-
- return ret;
-}
-
-// ============================================================================
-/*! \brief build a string representing a container in Naming Service.
- *
- * Build a string representing the absolute pathname of a container in
- * SALOME_NamingService.
- * \param params used as it is, or replaced by FactoryServer if empty.
- * \param hostname name of the host of the container, without domain names.
- * \return the path under the form /Containers/hostname/containerName
- * \sa ContainerName(const char *containerName)
- */
-// ============================================================================
-
-std::string SALOME_NamingService::BuildContainerNameForNS(const Engines::ContainerParameters& params, const char *hostname)
-{
- std::string ret("/Containers/");
- ret += hostname;
- ret += "/";
- ret += ContainerName(params);
-
- return ret;
-}
-
// ============================================================================
/*! \brief search a name in current directory.
*
* \param name the name to search.
* \return number of occurrences found.
* \sa Change_Directory(const char* Path)
- */
+ */
// ============================================================================
int SALOME_NamingService::Find(const char* name)
-throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
// ============================================================================
/*! \brief Creates a directory (context_name)
*
- * Creates a directory (context_name) relative to the current directory
+ * Creates a directory (context_name) relative to the current directory
* (current context) or relative to the root directory (root context), if
* the path given begins with a '/'.
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* as an absolute pathname. Else, pathname is taken as a relative
* path, to current context. Prefer absolute pathname, relative
* pathname are not safe, when SALOME_NamingService object is
- * shared or use in multithreaded context.
+ * shared or use in multithreaded context.
* \return true if successful
* (creation not strictly guaranteed if true, because Register may
* catch some specific unlikely exception without throw anything
* --- to be corrected ---)
* \sa RegisterCORBA::Object_ptr ObjRef, const char* Path)
- */
+ */
// ============================================================================
-bool SALOME_NamingService::Create_Directory(const char* Path) throw(ServiceUnreachable)
+bool SALOME_NamingService::Create_Directory(const char* Path)
{
Utils_Locker lock (&_myMutex);
}
// --- path must end with '/'
-
+
if (path[path.length()-1] != '/') path += '/';
Register(CORBA::Object::_nil(), path.c_str());
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \param Path the new current directory
* \return true if the change succeeded
- */
+ */
// ============================================================================
-bool SALOME_NamingService::Change_Directory(const char* Path) throw(ServiceUnreachable)
+bool SALOME_NamingService::Change_Directory(const char* Path)
{
Utils_Locker lock (&_myMutex);
// --- need to resolve directory path
ASSERT(!CORBA::is_nil(current_context));
-
+
if (path[path.length()-1] != '/') path += '/';
// SCRUTE(path);
CosNaming::Name context_name;
context_name,
splitPath,
true);
-
+
// --- Context creation
-
+
try
{
CORBA::Object_var obj = current_context->resolve(context_name);
_current_context = current_context;
changeOK = true;
}
-
+
catch (CosNaming::NamingContext::NotFound& ex)
{
CosNaming::Name n = ex.rest_of_name;
-
+
if (ex.why == CosNaming::NamingContext::missing_node)
MESSAGE( "Change_Directory() : " << (char *) n[0].id
<< " (" << (char *) n[0].kind << ") not found");
<< " (" << (char *) n[0].kind
<< ") is not an object" );
}
-
+
catch (CosNaming::NamingContext::CannotProceed&)
{
INFOS("Change_Directory(): CosNaming::NamingContext::CannotProceed");
}
-
+
catch (CosNaming::NamingContext::InvalidName&)
{
INFOS("Change_Directory(): CosNaming::NamingContext::InvalidName");
}
-
+
catch (CORBA::SystemException&)
{
INFOS("Change_Directory():CORBA::SystemException : unable to contact"
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \return the path of the current_context
* \sa _current_directory
- */
+ */
// ============================================================================
-char *SALOME_NamingService::Current_Directory() throw(ServiceUnreachable)
+char *SALOME_NamingService::Current_Directory()
{
Utils_Locker lock (&_myMutex);
}
std::string path;
- lengthPath = splitPath.size();
+ lengthPath = (int)splitPath.size(); //!< TODO: conversion from size_t to int
for (int k = 0 ; k < lengthPath ;k++)
{
path += "/";
* List and print via trace all directories and objects in the current
* context. Trace must be activated: compile option _DEBUG_
* If the NamingService is out, the exception ServiceUnreachable is thrown
- */
+ */
// ============================================================================
-void SALOME_NamingService::list() throw(ServiceUnreachable)
+void SALOME_NamingService::list()
{
Utils_Locker lock (&_myMutex)
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \return list of strings with objects found.
* \sa vector<string> list_directory_recurs()
- */
+ */
// ============================================================================
-std::vector<std::string> SALOME_NamingService::list_directory() throw(ServiceUnreachable)
+std::vector<std::string> SALOME_NamingService::list_directory()
{
Utils_Locker lock (&_myMutex);
std::vector<std::string> dirList ;
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \return list of strings with directories found.
* \sa vector<string> list_directory()
- */
+ */
// ============================================================================
-std::vector<std::string> SALOME_NamingService::list_subdirs() throw(ServiceUnreachable)
+std::vector<std::string> SALOME_NamingService::list_subdirs()
{
Utils_Locker lock (&_myMutex);
std::vector<std::string> dirList ;
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \return list of strings with objects found.
* \sa vector<string> list_directory()
- */
+ */
// ============================================================================
std::vector<std::string> SALOME_NamingService::list_directory_recurs()
-throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
/*! \brief destroy an entry in naming service.
*
* Destroy an association Path - Object Reference.
- * If the NamingService is out, the exception ServiceUnreachable is thrown
+ * If the NamingService is out, the exception ServiceUnreachable is thrown
* \param Path object path
- */
+ */
// ============================================================================
void SALOME_NamingService::Destroy_Name(const char* Path)
-throw(ServiceUnreachable)
+
{
Utils_Locker lock (&_myMutex);
// --- The current directory is now the directory where the object should
// be destroyed
- int sizePath = splitPath.size();
- if (sizePath > dimension_resultat)
+ size_t sizePath = splitPath.size();
+ if (sizePath > (size_t)dimension_resultat)
{
- ASSERT(sizePath == dimension_resultat+1);
+ ASSERT(sizePath == (size_t)dimension_resultat+1);
context_name.length(1);
try
CORBA::string_dup(splitPath[dimension_resultat].c_str());
context_name[0].kind = CORBA::string_dup("object");
//SCRUTE(context_name[0].id);
-
+
_current_context->unbind(context_name);
//MESSAGE("The object " << context_name[0].id << " has been deleted");
}
* Destroy an empty directory in Naming Service.
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \param Path directory path
- */
+ */
// ============================================================================
-void SALOME_NamingService::Destroy_Directory(const char* Path) throw(ServiceUnreachable)
+void SALOME_NamingService::Destroy_Directory(const char* Path)
{
Utils_Locker lock (&_myMutex);
/*! \brief Destroy a directory with its contents.
*
* Destroy the objects associations in a directory, and the directory itself,
- * if there is no subdirectories.
+ * if there is no subdirectories.
* If the NamingService is out, the exception ServiceUnreachable is thrown.
* \param Path the directory path.
- */
+ */
// ============================================================================
-void SALOME_NamingService::Destroy_FullDirectory(const char* Path) throw(ServiceUnreachable)
+void SALOME_NamingService::Destroy_FullDirectory(const char* Path)
{
//no need to lock here because method calls are threadsafe.
if( Change_Directory(Path) )
for (unsigned int ind = 0; ind < contList.size(); ind++)
Destroy_Name(contList[ind].c_str());
-
+
Destroy_Directory(Path);
}
}
/*! \brief initialize root context (root directory)
*
* the root context initialisation must be done when the SALOME_NamingService
- * instance is created and before any othe call. See constructors.
- */
+ * instance is created and before any other call. See constructors.
+ */
// ============================================================================
void SALOME_NamingService::_initialize_root_context()
* if false, final object (if any) is included in
* context_name.
* \return dimension of context_name
- */
+ */
// ============================================================================
int
endWithDelim = true;
if (endIdx == std::string::npos)
endIdx = path.length();
- int lsub = endIdx - begIdx;
+ size_t lsub = endIdx - begIdx;
if (lsub >= 1)
splitPath.push_back(path.substr(begIdx, lsub));
begIdx = path.find_first_not_of(delims, endIdx);
int dim;
if (onlyDir) // only directory part
{
- dim = splitPath.size()-1; // omit final object
- if (endWithDelim) // unless the path ends with a delimiter
+ dim = (int)splitPath.size()-1; // omit final object
+ if (endWithDelim) // unless the path ends with a delimiter
dim++;
endWithDelim = true;
}
else
- dim = splitPath.size(); // directories and final object
+ dim = (int)splitPath.size(); // directories and final object
- context_name.length(dim);
+ context_name.length((CORBA::ULong)dim);
for (int i=0; i<dim; i++)
{
// SCRUTE(splitPath[i]);
// MESSAGE("--- " <<splitPath[i] <<".dir");
}
}
- return dim;
+ return dim; //TODO: return <int> or <size_t>?
}
// ============================================================================
*
* \param name the name to search.
* \param occurence_number number of occurrence already found (incremented)
- */
+ */
// ============================================================================
void SALOME_NamingService::_Find(const char* name,
while (binding_iterator->next_one(binding))
{
CosNaming::Name bindingName = binding->binding_name;
-
+
if (binding->binding_type == CosNaming::ncontext)
{
// --- We work on a directory,
// the search should be done in this directory
-
+
Change_Directory(bindingName[0].id);
_Find(name, occurence_number);
-
+
// --- We'll go back to the initial context
-
+
_current_context = ref_context ;
}
-
+
else if (binding->binding_type == CosNaming::nobject)
{
// --- We work on an object...
-
+
if (!strcmp( bindingName[0].id, name))
{
//MESSAGE("One occurrence was found");
occurence_number++;
-
+
// --- We keep in memory the directory where
// one occurrence was found
-
+
found_context = _current_context ;
}
}
}
-
+
binding_iterator->destroy();
}
// --- We go to the last directory where an occurrence was found
// ============================================================================
/*! \brief find the current directory path.
- *
+ *
* Parse the naming service tree to find the current context and give the
* associated directory path (relative to root context).
- * \param splitPath
+ * \param splitPath
* \param lengthResult
* \param contextToFind
* \param notFound
- */
+ */
// ============================================================================
void
* \param relativeSubDir The directory relative to absCurDirectory in which
* the objects are found.
* \param absCurDirectory The current directory, absolute path
- */
+ */
// ============================================================================
void SALOME_NamingService::_list_directory_recurs(std::vector<std::string>& myList,
{
return _orb;
}
-