#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8 FATAL_ERROR)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.1 FATAL_ERROR)
INCLUDE(CMakeDependentOption)
PROJECT(SalomeKERNEL C CXX)
{
std::string tmp_str = file_path;
auto pos = file_path.rfind( _separator_ );
- if ( pos >= 0 ) // TODO: always true
+ if ( pos != std::string::npos )
tmp_str = pos < file_path.size()-1 ? file_path.substr( pos+1 ) : "";
pos = tmp_str.rfind( _extension_ );
- if( !with_extension && pos >= 0 ) // TODO: always true
+ if( !with_extension && pos != std::string::npos )
tmp_str = pos < tmp_str.size()-1 ? tmp_str.substr( 0, pos ) : "";
return tmp_str;
std::string GetDirName( const std::string& file_path )
{
auto pos = file_path.rfind( _separator_ );
- if ( pos >= 0 ) // TODO: always true
+ if ( pos != std::string::npos )
return pos < file_path.size()-1 ? file_path.substr(0, pos ) : "";
return std::string(".");
}
{
std::string tmp_str = name;
auto pos = tmp_str.rfind( _extension_ );
- if( pos < 0 ) // TODO: always true
+ if( pos == std::string::npos )
return tmp_str.append( _extension_ );
return tmp_str;
}
#include "SALOME_Basics.hxx"
#include <string>
#include <iostream>
-#define SALOME_UNUSED(var) (void)var
+
#ifndef WIN32
#include <sys/time.h>
#else
#pragma warning (disable : 4251)
#endif
+#ifndef SALOME_UNUSED
+#define SALOME_UNUSED(var) (void)var
+#endif
namespace Kernel_Utils
{
/*!
This method performs the transfert of double array with the remote SenderDouble given. If it fails with this SenderDouble it tries with an another protocol (CORBA by default).
*/
-double *ReceiverFactory::getValue(SALOME::SenderDouble_ptr sender,long &size)noexcept
+double *ReceiverFactory::getValue(SALOME::SenderDouble_ptr sender,long &size)
{
double *ret;
try{
/*!
This method performs the transfert of int array with the remote SenderInt given. If it fails with this SenderInt it tries with an another protocol (CORBA by default).
*/
-int *ReceiverFactory::getValue(SALOME::SenderInt_ptr sender,long &size)noexcept
+int *ReceiverFactory::getValue(SALOME::SenderInt_ptr sender,long &size)
{
int *ret;
try{
/*!
This method performs the transfert with the remote SenderDouble given. If it fails an exception is thrown.
*/
-double *ReceiverFactory::getValueOneShot(SALOME::SenderDouble_ptr sender,long &size)noexcept
+double *ReceiverFactory::getValueOneShot(SALOME::SenderDouble_ptr sender,long &size)
{
SALOME::CorbaDoubleNCSender_ptr cncD_ptr;
SALOME::CorbaDoubleCSender_ptr cwcD_ptr;
/*!
This method performs the transfert with the remote SenderInt given. If it fails an exception is thrown.
*/
-int *ReceiverFactory::getValueOneShot(SALOME::SenderInt_ptr sender,long &size)noexcept
+int *ReceiverFactory::getValueOneShot(SALOME::SenderInt_ptr sender,long &size)
{
SALOME::CorbaLongNCSender_ptr cncL_ptr;
SALOME::CorbaLongCSender_ptr cwcL_ptr;
class COMMUNICATION_EXPORT ReceiverFactory
{
public:
- static double *getValue(SALOME::SenderDouble_ptr sender,long &size)noexcept;
- static int *getValue(SALOME::SenderInt_ptr sender,long &size)noexcept;
+ static double *getValue(SALOME::SenderDouble_ptr sender,long &size);
+ static int *getValue(SALOME::SenderInt_ptr sender,long &size);
private:
- static double *getValueOneShot(SALOME::SenderDouble_ptr sender,long &size)noexcept;
- static int *getValueOneShot(SALOME::SenderInt_ptr sender,long &size)noexcept;
+ static double *getValueOneShot(SALOME::SenderDouble_ptr sender,long &size);
+ static int *getValueOneShot(SALOME::SenderInt_ptr sender,long &size);
};
#endif
return args;
}
-void SALOME_SocketSender_i::initCom()
+void SALOME_SocketSender_i::initCom()
{
struct sockaddr_in serv_addr;
socklen_t n;
SCRUTE(_port);
}
-void SALOME_SocketSender_i::acceptCom()
+void SALOME_SocketSender_i::acceptCom()
{
socklen_t sin_size;
struct sockaddr_in client_addr;
#define SALOME_CorbaLongSender SALOME_CorbaLongCSender_i
#endif
-SALOME::SenderDouble_ptr SenderFactory::buildSender(SALOMEMultiComm &multiCommunicator,const double *tab,long lgr,bool ownTab)noexcept {
+SALOME::SenderDouble_ptr SenderFactory::buildSender(SALOMEMultiComm &multiCommunicator,const double *tab,long lgr,bool ownTab) {
switch(multiCommunicator.getProtocol())
{
case SALOME::CORBA_:
}
}
-SALOME::SenderInt_ptr SenderFactory::buildSender(SALOMEMultiComm &multiCommunicator,const int *tab,long lgr,bool ownTab)noexcept {
+SALOME::SenderInt_ptr SenderFactory::buildSender(SALOMEMultiComm &multiCommunicator,const int *tab,long lgr,bool ownTab) {
switch(multiCommunicator.getProtocol())
{
case SALOME::CORBA_:
class COMMUNICATION_EXPORT SenderFactory
{
public:
- static SALOME::SenderDouble_ptr buildSender(SALOMEMultiComm &multiCommunicator,const double *tab,long lgr,bool ownTab=false) noexcept;
- static SALOME::SenderInt_ptr buildSender(SALOMEMultiComm &multiCommunicator,const int *tab,long lgr,bool ownTab=false) noexcept;
+ static SALOME::SenderDouble_ptr buildSender(SALOMEMultiComm &multiCommunicator,const double *tab,long lgr,bool ownTab=false);
+ static SALOME::SenderInt_ptr buildSender(SALOMEMultiComm &multiCommunicator,const int *tab,long lgr,bool ownTab=false);
static SALOME::SenderDouble_ptr buildSender(SALOME::TypeOfCommunication NewType,SALOME_SenderDouble_i *src);
static SALOME::SenderInt_ptr buildSender(SALOME::TypeOfCommunication NewType,SALOME_SenderInt_i *src);
};
Engines::FieldsDict* Engines_Component_i::getProperties()
{
Engines::FieldsDict_var copie = new Engines::FieldsDict;
- copie->length((_CORBA_ULong)_fieldsDict.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ copie->length((CORBA::ULong)_fieldsDict.size());
std::map<std::string,CORBA::Any>::iterator it;
CORBA::ULong i = 0;
for (it = _fieldsDict.begin(); it != _fieldsDict.end(); it++, i++)
*/
//=============================================================================
-Engines::TMPFile* Engines_Component_i::DumpPython(CORBA::Boolean isPublished,
+Engines::TMPFile* Engines_Component_i::DumpPython(CORBA::Boolean /*isPublished*/,
CORBA::Boolean isMultiFile,
CORBA::Boolean& isValidScript)
{
- SALOME_UNUSED(isPublished);
const char* aScript = isMultiFile ? "def RebuildData(): pass" : "";
char* aBuffer = new char[strlen(aScript)+1];
strcpy(aBuffer, aScript);
- CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer;
- int aBufferSize = (int)strlen(aBuffer)+1; //!< TODO: conversion from size_t to int
- Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aBufferSize, aBufferSize, anOctetBuf, 1);
+ size_t aBufferSize = strlen(aBuffer)+1;
+ Engines::TMPFile_var aStreamFile = new Engines::TMPFile((CORBA::ULong)aBufferSize, (CORBA::ULong)aBufferSize, (CORBA::Octet*)aBuffer, 1);
isValidScript = true;
return aStreamFile._retn();
}
*/
//=============================================================================
void
-Engines_Component_i::configureSalome_file(std::string service_name,
- std::string file_port_name,
- Salome_file_i * file)
+Engines_Component_i::configureSalome_file(std::string /*service_name*/,
+ std::string /*file_port_name*/,
+ Salome_file_i* /*file*/)
{
- SALOME_UNUSED(file);
// By default this method does nothing
}
//=============================================================================
/*!
- \brief Get version of the component
-
- This method is supposed to be implemented in all derived classes; default implementation
- returns empty string that means that no version information about the component is available.
+ * \brief Return \c true if component can provide creation information.
+ */
+//=============================================================================
+bool Engines_Component_i::hasObjectInfo()
+{
+ return false;
+}
- \note The version of the component is stored to the study, as a part of general persistence
- mechanism; once stored, version information in the study cannot be changed.
+//=============================================================================
+/*!
+ * \brief Get creation information for object addressed by given entry.
+ */
+//=============================================================================
+char* Engines_Component_i::getObjectInfo(const char* /*entry*/)
+{
+ return CORBA::string_dup("");
+}
- \return string containing component's version, e.g. "1.0"
-*/
+//=============================================================================
+/*!
+ * \brief Get version of the component
+ *
+ * This method is supposed to be implemented in all derived classes; default implementation
+ * returns empty string that means that no version information about the component is available.
+ *
+ * \note The version of the component is stored to the study, as a part of general persistence
+ * mechanism; once stored, version information in the study cannot be changed.
+ *
+ * \return string containing component's version, e.g. "1.0"
+ */
+//=============================================================================
char* Engines_Component_i::getVersion()
{
return CORBA::string_dup( "" );
{
itm->second->destroy();
}
- catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable
+ catch(const CORBA::Exception&)
{
// ignore this entry and continue
}
Engines::EngineComponent_ptr
Engines_Container_i::load_impl( const char* genericRegisterName,
- const char* componentName )
+ const char* /*componentName*/ )
{
- SALOME_UNUSED(componentName);
char* reason;
std::string impl_name = std::string(LIB) + genericRegisterName + ENGINESO;
Engines::EngineComponent_var iobject = Engines::EngineComponent::_nil() ;
#include "utilities.h"
#include "Container_init_python.hxx"
-#include "Basics_Utils.hxx"
#if PY_VERSION_HEX < 0x03050000
static char*
}
static PyObject*
-ContainerPyStdOut_flush(ContainerPyStdOut *self)
+ContainerPyStdOut_flush(ContainerPyStdOut* /*self*/)
{
- SALOME_UNUSED(self);
Py_INCREF(Py_None);
return Py_None;
}
MESSAGE("=================================================================");
// set stdout to line buffering (aka C++ std::cout)
setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
- wchar_t* salome_python; //!< TODO: unused variable
char* env_python=getenv("SALOME_PYTHON");
if(env_python != 0)
{
#include <SALOMEconfig.h>
-#include "Basics_Utils.hxx"
#include "SALOME_Container.hxx"
#include <iostream>
const char* Salome_file_name);
// Object information
- virtual bool hasObjectInfo() { return false; }
- virtual char* getObjectInfo(const char* entry) { SALOME_UNUSED(entry); return CORBA::string_dup(""); }
+ virtual bool hasObjectInfo();
+ virtual char* getObjectInfo(const char* entry);
// Version information
virtual char* getVersion();
break;
}
}
- catch(const SALOME_Exception & ex) //!< TODO: unused variable
+ catch(const SALOME_Exception &ex) //!< TODO: unused variable
{
MESSAGE("[GiveContainer] Exception in ResourceManager find !: " << ex.what());
return ret;
const Engines::ContainerParameters& /*params*/,
const std::string& /*name*/,
SALOME_ContainerManager::actual_launch_machine_t & /*vect_machine*/)
-{
- return false;
+{
+ return false;
}
#endif
CORBA::Octet *buf;
buf = Engines::fileBlock::allocbuf(FILEBLOCK_SIZE);
- int nbRed = (int)fread(buf, sizeof(CORBA::Octet), FILEBLOCK_SIZE, fp); //!< TODO: conversion from size_t to int
+ size_t nbRed = fread(buf, sizeof(CORBA::Octet), FILEBLOCK_SIZE, fp);
//SCRUTE(nbRed);
- aBlock->replace(nbRed, nbRed, buf, 1); // 1 means give ownership
+ aBlock->replace((CORBA::ULong)nbRed, (CORBA::ULong)nbRed, buf, 1); // 1 means give ownership
return aBlock;
}
// $Header:
//
#include "Salome_file_i.hxx"
-#include "Basics_Utils.hxx"
#include "utilities.h"
#include <stdlib.h>
#include "HDFOI.hxx"
throw SALOME::SALOME_Exception(es);
};
hdf_dataset->ReadFromDisk(buffer);
- if ( write(fd,buffer, static_cast<unsigned int>(size)) <0) {
+ if ( write(fd,buffer,(unsigned int)size) <0) {
SALOME::ExceptionStruct es;
es.type = SALOME::INTERNAL_ERROR;
std::string text = "write failed";
std::string cp_file_name(comp_file_name);
std::size_t index = cp_file_name.rfind("/");
- if (index != -1) //TODO: std::string::npos
+ if (index != std::string::npos)
{
file_name = cp_file_name.substr(index+1);
path = cp_file_name.substr(0,index+1);
std::string cp_file_name(comp_file_name);
std::size_t index = cp_file_name.rfind("/");
- if (index != -1) //TODO: std::string::npos
+ if (index != std::string::npos)
{
file_name = cp_file_name.substr(index+1);
path = cp_file_name.substr(0,index+1);
*/
//=============================================================================
void
-Salome_file_i::removeFile(const char* file_name)
+Salome_file_i::removeFile(const char* /*file_name*/)
{
- SALOME_UNUSED(file_name);
MESSAGE("Salome_file_i::removeFile : NOT YET IMPLEMENTED");
}
Salome_file_i::getFilesInfos() {
Engines::files * infos = new Engines::files();
- infos->length(static_cast<unsigned long>(_fileManaged.size()));
+ infos->length((CORBA::ULong)_fileManaged.size());
_t_fileManaged::iterator begin = _fileManaged.begin();
_t_fileManaged::iterator end = _fileManaged.end();
CORBA::Octet *buf;
buf = Engines::fileBlock::allocbuf(FILEBLOCK_SIZE);
size_t nbRed = fread(buf, sizeof(CORBA::Octet), FILEBLOCK_SIZE, fp);
- aBlock->replace((_CORBA_ULong)nbRed, (_CORBA_ULong)nbRed, buf, 1); // 1 means give ownership //!< TODO: conversion from size_t to _CORBA_ULong
+ aBlock->replace((CORBA::ULong)nbRed, (CORBA::ULong)nbRed, buf, 1); // 1 means give ownership //!< TODO: conversion from size_t to CORBA::ULong
return aBlock;
}
#include "DF_definitions.hxx"
#include "DF_Application.hxx"
-#include "Basics_Utils.hxx"
//Constructor
DF_Application::DF_Application()
//Returns a number of existent documents
int DF_Application::NbDocuments()
{
- //TODO: return <size_t> ot <int>?
- return static_cast<int>(_documents.size());
+ return (int)_documents.size() ;
}
//Restores a Document from the given file, returns a smart
//pointer to opened document.
-DF_Document* DF_Application::Open(const std::string& theFileName)
+DF_Document* DF_Application::Open(const std::string& /*theFileName*/)
{
- SALOME_UNUSED(theFileName);
//Not implemented
return NULL;
}
//Saves a Document in a given file with name theFileName
-void DF_Application::SaveAs(const DF_Document* theDocument, const std::string& theFileName)
+void DF_Application::SaveAs(const DF_Document* /*theDocument*/, const std::string& /*theFileName*/)
{
- SALOME_UNUSED(theDocument);
- SALOME_UNUSED(theFileName);
//Not implemented
}
#include "DF_Document.hxx"
#include "DF_Label.hxx"
#include "DF_ChildIterator.hxx"
-#include "Basics_Utils.hxx"
//Class DF_Document is container for user's data stored as a tree of Labels
//with assigned Attributes
//Restores a content of the Document from the std::string theData
-void DF_Document::Load(const std::string& theData)
+void DF_Document::Load(const std::string& /*theData*/)
{
- SALOME_UNUSED(theData);
//Not implemented
}
//Constructor
Standard_EXPORT DF_Document(const std::string& theDocumentType);
- Standard_EXPORT ~DF_Document();
+ Standard_EXPORT virtual ~DF_Document();
Standard_EXPORT DF_Application* GetApplication();
virtual void add_provides_port(Ports::Port_ptr ref,
const char* provides_port_name,
Ports::PortProperties_ptr port_prop)
- noexcept {
+ {
Engines_DSC_interface::add_provides_port(ref,
provides_port_name,
port_prop);
virtual void add_uses_port(const char* repository_id,
const char* uses_port_name,
Ports::PortProperties_ptr port_prop)
- noexcept {
+ {
Engines_DSC_interface::add_uses_port(repository_id,
uses_port_name,
port_prop);
*/
virtual Ports::Port_ptr get_provides_port(const char* provides_port_name,
const CORBA::Boolean connection_error)
- noexcept {
+ {
return Engines_DSC_interface::get_provides_port(provides_port_name,
connection_error);
}
* \see Engines::DSC::get_uses_port
*/
virtual Engines::DSC::uses_port * get_uses_port(const char* uses_port_name)
- noexcept {
+ {
return Engines_DSC_interface::get_uses_port(uses_port_name);
}
* \see Engines::DSC::connect_provides_port
*/
virtual void connect_provides_port(const char* provides_port_name)
- noexcept {
+ {
Engines_DSC_interface::connect_provides_port(provides_port_name);
}
*/
virtual void connect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref)
- noexcept {
- Engines_DSC_interface::connect_uses_port(uses_port_name,
- provides_port_ref);
- }
+ {
+ Engines_DSC_interface::connect_uses_port(uses_port_name,
+ provides_port_ref);
+ }
/*!
* \see Engines::DSC::is_connected
*/
virtual CORBA::Boolean is_connected(const char* port_name)
- noexcept {
+ {
return Engines_DSC_interface::is_connected(port_name);
}
*/
virtual void disconnect_provides_port(const char* provides_port_name,
const Engines::DSC::Message message)
- noexcept {
+ {
Engines_DSC_interface::disconnect_provides_port(provides_port_name,
message);
}
virtual void disconnect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref,
const Engines::DSC::Message message)
- noexcept {
+ {
Engines_DSC_interface::disconnect_uses_port(uses_port_name,
provides_port_ref,
message);
* \see Engines::DSC::get_port_properties
*/
virtual Ports::PortProperties_ptr get_port_properties(const char* port_name)
- noexcept {
+ {
return Engines_DSC_interface::get_port_properties(port_name);
}
};
Engines_DSC_interface::add_provides_port(Ports::Port_ptr ref,
const char* provides_port_name,
Ports::PortProperties_ptr port_prop)
- noexcept
{
// Method args test
assert(provides_port_name);
Engines_DSC_interface::add_uses_port(const char* repository_id,
const char* uses_port_name,
Ports::PortProperties_ptr port_prop)
- noexcept
{
// Method args test
// Note : We can't be shure that repository id
Ports::Port_ptr
Engines_DSC_interface::get_provides_port(const char* provides_port_name,
const CORBA::Boolean connection_error)
- noexcept
{
// Method arg test
assert(provides_port_name);
Engines::DSC::uses_port *
Engines_DSC_interface::get_uses_port(const char* uses_port_name)
-noexcept
{
// Method arg test
assert(uses_port_name);
void
Engines_DSC_interface::connect_provides_port(const char* provides_port_name)
-noexcept
{
// Method arg test
assert(provides_port_name);
void
Engines_DSC_interface::connect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref)
- noexcept
{
// Method arg test
assert(uses_port_name);
CORBA::Boolean
Engines_DSC_interface::is_connected(const char* port_name)
-noexcept
{
CORBA::Boolean rtn = false;
void
Engines_DSC_interface::disconnect_provides_port(const char* provides_port_name,
const Engines::DSC::Message message)
- noexcept
{
// Method args test
assert(provides_port_name);
Engines_DSC_interface::disconnect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref,
const Engines::DSC::Message message)
- noexcept
{
// Method args test
assert(uses_port_name);
Ports::PortProperties_ptr
Engines_DSC_interface::get_port_properties(const char* port_name)
-noexcept
{
Ports::PortProperties_ptr rtn_properties = Ports::PortProperties::_nil();
*/
virtual void add_provides_port(Ports::Port_ptr ref,
const char* provides_port_name,
- Ports::PortProperties_ptr port_prop)
- noexcept;
+ Ports::PortProperties_ptr port_prop);
/*!
* \see Engines::DSC::add_uses_port
*/
virtual void add_uses_port(const char* repository_id,
const char* uses_port_name,
- Ports::PortProperties_ptr port_prop)
- noexcept;
+ Ports::PortProperties_ptr port_prop);
/*!
* \see Engines::DSC::get_provides_port
*/
virtual Ports::Port_ptr get_provides_port(const char* provides_port_name,
- const CORBA::Boolean connection_error)
- noexcept;
+ const CORBA::Boolean connection_error);
/*!
* \see Engines::DSC::get_uses_port
*/
- virtual Engines::DSC::uses_port * get_uses_port(const char* uses_port_name)
- noexcept;
+ virtual Engines::DSC::uses_port * get_uses_port(const char* uses_port_name);
/*!
* \see Engines::DSC::connect_provides_port
* port doesn't know its uses ports references. It's framework or application role
* to manage connections between ports.
*/
- virtual void connect_provides_port(const char* provides_port_name)
- noexcept;
+ virtual void connect_provides_port(const char* provides_port_name);
/*!
* \see Engines::DSC::connect_uses_port
* port how much provides ports are connected with.
*/
virtual void connect_uses_port(const char* uses_port_name,
- Ports::Port_ptr provides_port_ref)
- noexcept;
+ Ports::Port_ptr provides_port_ref);
/*!
* \see Engines::DSC::is_connected
*/
- virtual CORBA::Boolean is_connected(const char* port_name)
- noexcept;
+ virtual CORBA::Boolean is_connected(const char* port_name);
/*!
* \see Engines::DSC::disconnect_provides_port
* to manage connections between ports.
*/
virtual void disconnect_provides_port(const char* provides_port_name,
- const Engines::DSC::Message message)
- noexcept;
+ const Engines::DSC::Message message);
/*!
* \see Engines::DSC::disconnect_uses_port
*/
virtual void disconnect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref,
- const Engines::DSC::Message message)
- noexcept;
+ const Engines::DSC::Message message);
/*!
* \see Engines::DSC::get_port_properties
*/
- virtual Ports::PortProperties_ptr get_port_properties(const char* port_name)
- noexcept;
+ virtual Ports::PortProperties_ptr get_port_properties(const char* port_name);
static void writeEvent(const char* request,const std::string& containerName, const char* instance_name,
const char* port_name, const char* error, const char* message);
PortProperties_i::~PortProperties_i() {}
void
-PortProperties_i::set_property(const char * /*name*/, const CORBA::Any& /*value*/)
-noexcept
+PortProperties_i::set_property(const char* /*name*/, const CORBA::Any& /*value*/)
{
// Default case, the object has no properties.
throw Ports::NotDefined();
CORBA::Any*
PortProperties_i::get_property(const char* /*name*/)
-noexcept
{
// Default case, the object has no properties.
throw Ports::NotDefined();
* CORBA method : set a value to a property
* \see Ports::PortProperties::set_property
*/
- virtual void set_property(const char * /*name*/,
- const CORBA::Any& /*value*/)
- noexcept;
+ virtual void set_property(const char* name,
+ const CORBA::Any& value);
/*!
* CORBA method : get the value of a property
* \see Ports::PortProperties::get_property
*/
- virtual CORBA::Any* get_property(const char* /*name*/)
- noexcept;
+ virtual CORBA::Any* get_property(const char* name);
};
#endif
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-FIND_PACKAGE(SWIG REQUIRED)
INCLUDE(${SWIG_USE_FILE})
SET_SOURCE_FILES_PROPERTIES(calcium.i PROPERTIES CPLUSPLUS ON)
// Le destructeur de la SALOME_Exception devrait être virtuel
// sinon pb avec nos attributs de type pointeur.
- virtual ~DSC_Exception(void) {};
+ virtual ~DSC_Exception(void) noexcept {};
virtual const std::string & getExceptionName() const {return _exceptionName;};
) : DSC_Exception(text,fileName,lineNumber,funcName) { \
_exceptionName = #Derived; \
} \
- virtual ~Derived(void);\
+ virtual ~Derived(void) noexcept;\
};\
//Sert à eviter le problème d'identification RTTI des exceptions
//Crée un unique typeInfo pour tous les bibliothèques composants SALOME
//dans un fichier cxx
-#define DSC_EXCEPTION_CXX(NameSpace,Derived) NameSpace::Derived::~Derived(void) {}
+#define DSC_EXCEPTION_CXX(NameSpace,Derived) NameSpace::Derived::~Derived(void) noexcept {}
#endif /* DSC_EXCEPTION_HXX */
DSC_Exception(ex),_info(info),_exceptionName("CalciumException")
{};
- virtual ~CalciumException() {};
+ virtual ~CalciumException() noexcept {};
CalciumTypes::InfoType getInfo() const { return _info;}
void setInfo(CalciumTypes::InfoType info) {_info=info;}
virtual const std::string & getExceptionName() const {return _exceptionName;};
return POA_Ports::PortProperties::_this(); \
} \
\
- virtual void set_property(const char * name, const CORBA::Any& value) \
- ; \
+ virtual void set_property(const char * name, const CORBA::Any& value); \
\
- virtual CORBA::Any* get_property(const char* name) \
- ; \
+ virtual CORBA::Any* get_property(const char* name); \
\
virtual void provides_port_changed(int /*connection_nbr*/, \
const Engines::DSC::Message message) { \
specificPortName::~specificPortName(void) {} \
\
void specificPortName::set_property(const char * name, const CORBA::Any& value) \
- { \
+ { \
\
const std::string key(name); \
CORBA::Long sl; \
\
\
CORBA::Any* specificPortName::get_property(const char* name) \
- { \
+ { \
const std::string key(name); \
CORBA::Any* value=new CORBA::Any; \
if (key == "StorageLevel" ) \
PortableServer::ObjectId * contId,
const char *instanceName,
const char *interfaceName,
- bool notif) :
+ bool /*notif*/) :
Engines_DSC_i(orb, poa, contId, instanceName, interfaceName)
{
- SALOME_UNUSED(notif);
#ifdef MYDEBUG
std::cerr << "--Superv_Component_i : MARK 1 ---- " << instanceName << "----" << std::endl;
#endif
void
Superv_Component_i::get_uses_port_names(std::vector<std::string> & port_names,
- const std::string servicename) const {
- SALOME_UNUSED(servicename);
+ const std::string /*servicename*/) const
+{
port_names.reserve(my_superv_ports.size());
superv_ports::const_iterator it;
#include "uses_port.hxx"
#include "provides_port.hxx"
#include "port_factory.hxx"
-#include "Basics_Utils.hxx"
#include "DSC_Exception.hxx"
#include <vector>
/*!
* \warning currently disabled.
*/
- virtual provides_port * create_provides_data_and_control_port(const char* port_type)
- {SALOME_UNUSED(port_type);return NULL;}
+ virtual provides_port * create_provides_data_and_control_port(const char* /*port_type*/)
+ {return NULL;}
/*!
* \warning currently disabled.
/*!
* \warning currently disabled.
*/
- virtual uses_port * create_uses_data_and_control_port(const char* port_type)
- {SALOME_UNUSED(port_type);return NULL;}
+ virtual uses_port * create_uses_data_and_control_port(const char* /*port_type*/)
+ {return NULL;}
/*!
* This method permits to create a provides port provided by the platform.
*
* \note It's user repsonsability to destroy the provides port.
*/
- virtual provides_port * create_provides_data_port(const std::string& port_fab_type)
- ;
+ virtual provides_port * create_provides_data_port(const std::string& port_fab_type);
/*!
*
* \note It's user repsonsability to destroy the uses port.
*/
- virtual uses_port * create_uses_data_port(const std::string& port_fab_type)
- ;
+ virtual uses_port * create_uses_data_port(const std::string& port_fab_type);
/*!
* Adds a port to the component. With this method only Salomé's provided DSC ports
*/
virtual void add_port(const char * port_fab_type,
const char * port_type,
- const char * port_name)
- ;
+ const char * port_name);
/*!
* Adds a port to the component. With this method only Salomé's provided DSC ports
template < typename SpecificPortType >
SpecificPortType * add_port(const char * port_fab_type,
const char * port_type,
- const char * port_name)
- ;
+ const char * port_name);
/*!
* Adds a created provides port to the component.
* \param provides_port_name the name of the port in the component.
*/
virtual void add_port(provides_port * port,
- const char* provides_port_name)
- ;
+ const char* provides_port_name);
/*!
* Adds a created uses port to the component.
* \param uses_port_name the name of the port in the component.
*/
virtual void add_port(uses_port * port,
- const char* uses_port_name)
- ;
+ const char* uses_port_name);
/*!
* Gets the provides port already added in the component.
* \param provides_port_name the name of the port.
*/
virtual void get_port(provides_port *& port,
- const char* provides_port_name)
- ;
+ const char* provides_port_name);
/*!
* Gets the uses port already added in the component.
* \param uses_port_name the name of the port.
*/
virtual void get_port(uses_port *& port,
- const char* uses_port_name)
- ;
+ const char* uses_port_name);
/*!
* Gets the list of the ports of a service.
* \return a port's pointer.
*/
template <typename SpecificPortType >
- SpecificPortType * get_port( const char * port_name)
- ;
+ SpecificPortType * get_port( const char * port_name);
/*!
* \see DSC_Callbacks::provides_port_changed
// This method is implemented by default since it is a very specific usage.
// It also permits to not break compatibility with older components.
- virtual CORBA::Boolean init_service_with_multiple(const char* service_name,
- const Engines::Superv_Component::seq_multiple_param & params)
+ virtual CORBA::Boolean init_service_with_multiple(const char* /*service_name*/,
+ const Engines::Superv_Component::seq_multiple_param & /*params*/)
{
- SALOME_UNUSED(service_name);
- SALOME_UNUSED(params);
return true;
}
virtual void add_provides_port(Ports::Port_ptr ref,
const char* provides_port_name,
Ports::PortProperties_ptr port_prop)
- {
+ {
Engines_DSC_interface::add_provides_port(ref,
provides_port_name,
port_prop);
virtual void add_uses_port(const char* repository_id,
const char* uses_port_name,
Ports::PortProperties_ptr port_prop)
- {
+ {
Engines_DSC_interface::add_uses_port(repository_id,
uses_port_name,
port_prop);
*/
virtual Ports::Port_ptr get_provides_port(const char* provides_port_name,
const CORBA::Boolean connection_error)
- {
+ {
return Engines_DSC_interface::get_provides_port(provides_port_name,
connection_error);
}
* \see Engines::DSC::get_uses_port
*/
virtual Engines::DSC::uses_port * get_uses_port(const char* uses_port_name)
- {
+ {
return Engines_DSC_interface::get_uses_port(uses_port_name);
}
* \see Engines::DSC::connect_provides_port
*/
virtual void connect_provides_port(const char* provides_port_name)
- {
+ {
Engines_DSC_interface::connect_provides_port(provides_port_name);
}
*/
virtual void connect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref)
- {
- Engines_DSC_interface::connect_uses_port(uses_port_name,
- provides_port_ref);
- }
+ {
+ Engines_DSC_interface::connect_uses_port(uses_port_name,
+ provides_port_ref);
+ }
/*!
* \see Engines::DSC::is_connected
*/
virtual CORBA::Boolean is_connected(const char* port_name)
- {
+ {
return Engines_DSC_interface::is_connected(port_name);
}
*/
virtual void disconnect_provides_port(const char* provides_port_name,
const Engines::DSC::Message message)
- {
+ {
Engines_DSC_interface::disconnect_provides_port(provides_port_name,
message);
}
virtual void disconnect_uses_port(const char* uses_port_name,
Ports::Port_ptr provides_port_ref,
const Engines::DSC::Message message)
- {
+ {
Engines_DSC_interface::disconnect_uses_port(uses_port_name,
provides_port_ref,
message);
}
virtual Ports::PortProperties_ptr get_port_properties(const char* port_name)
- {
+ {
return Engines_DSC_interface::get_port_properties(port_name);
}
fprintf(fp, " %li\n", ndim);
for(int i = 0;i < ndim;i++) {
- fprintf(fp, " %li", dim[i]);
+ fprintf(fp, " %lu", (unsigned long)dim[i]);
}
fprintf(fp, "\n");
delete [] dim;
- fprintf(fp, "%i %i:", size, order);
+ fprintf(fp, "%li %i:", size, order);
if( type == HDF_ARRAY ) {
HDFarray *array = new HDFarray(hdf_dataset);
hdf_type data_type = array->GetDataType();
array->GetDim(arr_dim);
for( int i = 0;i < arr_ndim; i++ ) {
- fprintf(fp, " %i", arr_dim[i]);
+ fprintf(fp, " %lu", (unsigned long)arr_dim[i]);
}
//And write the data array
// function : SaveAttributeInASCIIfile
// purpose :
//============================================================================
-void SaveAttributeInASCIIfile(HDFattribute *hdf_attribute, FILE* fp, int ident)
+void SaveAttributeInASCIIfile(HDFattribute *hdf_attribute, FILE* fp, int /*ident*/)
{
- SALOME_UNUSED(ident);
hdf_attribute->OpenOnDisk();
hdf_type type = hdf_attribute->GetType();
size_t size = hdf_attribute->GetSize();
fprintf(fp, "%s\n", ATTRIBUTE_ID);
- fprintf(fp, "%s %i %i\n", name, type, size);
+ fprintf(fp, "%s %i %lu\n", name, type, size);
delete [] name;
bool CreateDatasetFromASCII(HDFcontainerObject *father, FILE *fp)
{
char name[HDF_NAME_MAX_LEN+1];
- hdf_type type;
- hdf_byte_order order;
+ int type;
+ int order;
int nbDim, nbAttr;
long i, size;
HDFarray* anArray = 0;
if( type == HDF_ARRAY ){
//Get array information
- hdf_type arr_data_type;
+ int arr_data_type;
int arr_ndim;
fscanf(fp, "%c", &tmp);
fscanf(fp, " %i\n", &arr_data_type ); //Get array data type
fscanf(fp, " %i", &tdim);
arr_dim[i] = tdim;
}
- anArray = new HDFarray(0, arr_data_type, arr_ndim, arr_dim);
+ anArray = new HDFarray(0, (hdf_type)arr_data_type, arr_ndim, arr_dim);
anArray->CreateOnDisk();
type = arr_data_type;
delete [] arr_dim;
}
- HDFdataset* hdf_dataset = new HDFdataset(new_name, father, anArray ? HDF_ARRAY : type, sizeArray, nbDim, order);
+ HDFdataset* hdf_dataset = new HDFdataset(new_name, father, anArray ? HDF_ARRAY : (hdf_type)type, sizeArray, nbDim, (hdf_byte_order)order);
if(anArray)
hdf_dataset->SetArrayId(anArray->GetId());
} else if(type == HDF_CHAR) {
hdf_char* val = new hdf_char[size];
for(i=0; i<size; i++) {
- fscanf(fp, " %hhi", &(val[i]));
+ fscanf(fp, " %c", &(val[i]));
}
hdf_dataset->WriteOnDisk(val);
delete [] val;
{
char name[HDF_NAME_MAX_LEN+1];
- hdf_type type;
+ int type;
int size;
fscanf(fp, "%s %i %i\n", name, &type, &size);
char* new_name = restoreName(name);
- HDFattribute* hdf_attribute = new HDFattribute(new_name, father, type, size);
+ HDFattribute* hdf_attribute = new HDFattribute(new_name, father, (hdf_type)type, size);
hdf_attribute->CreateOnDisk();
void write_float64(FILE* fp, hdf_float64* value)
{
unsigned char* array = (unsigned char*)value;
- for(int i = 0; i < sizeof(hdf_float64); i++) {
+ for(int i = 0; i < (int)sizeof(hdf_float64); i++) {
unsigned tmp = (unsigned short)array[i];
fprintf(fp, " %2x", tmp);
}
void read_float64(FILE* fp, hdf_float64* value)
{
unsigned char* array = (unsigned char*)value;
- for(int i = 0; i < sizeof(hdf_float64); i++) {
+ for(int i = 0; i < (int)sizeof(hdf_float64); i++) {
unsigned tmp;
fscanf(fp, " %x", &tmp);
array[i] = (unsigned char)tmp;
#include "hdfi.h"
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
-#include "Basics_Utils.hxx"
HDFcontainerObject::HDFcontainerObject(const char *name)
: HDFinternalObject(name)
return 0;
}
-void HDFcontainerObject::InternalObjectIndentify(int rank, char *object_name)
+void HDFcontainerObject::InternalObjectIndentify(int /*rank*/, char *object_name)
{
- SALOME_UNUSED(rank);
object_name = NULL;
}
return -1;
};
- // TODO: return <int> or <size_t>?
- return static_cast<int>(length);
+ return (int)length;
}
#include "HDFdataset.hxx"
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
-#include "Basics_Utils.hxx"
#include <iostream>
-herr_t dataset_attr(hid_t loc_id, const char *attr_name, void *operator_data)
+herr_t dataset_attr(hid_t /*loc_id*/, const char *attr_name, void *operator_data)
{
- SALOME_UNUSED(loc_id);
*(char**)operator_data = new char[strlen(attr_name)+1];
strcpy(*(char**)operator_data, attr_name);
return 1;
#include <iostream>
#include "HDFfile.hxx"
#include "HDFexception.hxx"
-#include "Basics_Utils.hxx"
-herr_t file_attr(hid_t loc_id, const char *attr_name, void *operator_data)
+herr_t file_attr(hid_t /*loc_id*/, const char *attr_name, void *operator_data)
{
- SALOME_UNUSED(loc_id);
*(char**)operator_data = new char[strlen(attr_name)+1];
strcpy(*(char**)operator_data, attr_name);
return 1;
#include <string.h>
#include "HDFgroup.hxx"
#include "HDFexception.hxx"
-#include "Basics_Utils.hxx"
-herr_t group_attr(hid_t loc_id, const char *attr_name, void *operator_data)
+herr_t group_attr(hid_t /*loc_id*/, const char *attr_name, void *operator_data)
{
- SALOME_UNUSED(loc_id);
*(char**)operator_data = new char[strlen(attr_name)+1];
strcpy(*(char**)operator_data, attr_name);
return 1;
-// Copyright (C) 2007-2020 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
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
+/* Copyright (C) 2007-2020 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
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+ */
/*----------------------------------------------------------------------------
SALOME HDFPersist : implementation of HDF persitent ( save/ restore )
#include "hdfi.h"
#include <stdlib.h>
+
/*
* - Name : HDFnObjects
* - Description : returns the number of HDF objects in an HDF group
int *count;
(void)name;
(void)id;
+
count = (int *) data;
(*count)++;
-// Copyright (C) 2007-2020 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
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
+/* Copyright (C) 2007-2020 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
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+ */
/*----------------------------------------------------------------------------
SALOME HDFPersist : implementation of HDF persitent ( save/ restore )
hdf_err RankInfo(hdf_idt id, const char *name, void *data)
{
(void)id;
+
if ( data )
strcpy( (char*)data, name );
else
-// Copyright (C) 2007-2020 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
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
+/* Copyright (C) 2007-2020 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
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+ */
/*----------------------------------------------------------------------------------
SALOME HDFPersist : implementation of HDF persitent ( save/ restore )
-// Copyright (C) 2007-2020 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
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
+/* Copyright (C) 2007-2020 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
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+ */
/*----------------------------------------------------------------------
SALOME HDFPersist : implementation of HDF persitent ( save/ restore )
SALOMEDS_DriverDefaultImpl();
public:
- SALOMEDS_DriverDefaultImpl(CORBA::ORB_ptr /*orb*/,
- PortableServer::POA_ptr /*poa*/,
- PortableServer::ObjectId * /*contId*/,
- const char * /*instanceName*/,
- const char * /*interfaceName*/);
+ SALOMEDS_DriverDefaultImpl(CORBA::ORB_ptr orb,
+ PortableServer::POA_ptr poa,
+ PortableServer::ObjectId * contId,
+ const char * instanceName,
+ const char * interfaceName);
virtual ~SALOMEDS_DriverDefaultImpl();
//---------------------------------------------
//virtual SALOMEDS::TMPFile* Save(SALOMEDS::SComponent_ptr theComponent,
- SALOMEDS::TMPFile* Save(SALOMEDS::SComponent_ptr /*theComponent*/,
- const char* /*theURL*/,
- bool /*isMultiFile*/);
+ SALOMEDS::TMPFile* Save(SALOMEDS::SComponent_ptr theComponent,
+ const char* theURL,
+ bool isMultiFile);
- virtual SALOMEDS::TMPFile* SaveASCII(SALOMEDS::SComponent_ptr /*theComponent*/,
- const char* /*theURL*/,
- bool /*isMultiFile*/);
+ virtual SALOMEDS::TMPFile* SaveASCII(SALOMEDS::SComponent_ptr theComponent,
+ const char* theURL,
+ bool isMultiFile);
virtual bool Load(SALOMEDS::SComponent_ptr,
const SALOMEDS::TMPFile &,
const char* theURL,
bool isMultiFile);
- virtual void Close(SALOMEDS::SComponent_ptr /*IORSComponent*/);
+ virtual void Close(SALOMEDS::SComponent_ptr IORSComponent);
virtual char* ComponentDataType();
- virtual char* IORToLocalPersistentID(SALOMEDS::SObject_ptr /*theSObject*/,
- const char* /*IORString*/,
- CORBA::Boolean /*isMultiFile*/,
- CORBA::Boolean /*isASCII*/);
+ virtual char* IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
+ const char* IORString,
+ CORBA::Boolean isMultiFile,
+ CORBA::Boolean isASCII);
- virtual char* LocalPersistentIDToIOR(SALOMEDS::SObject_ptr /*theSObject*/,
- const char* /*aLocalPersistentID*/,
- CORBA::Boolean /*isMultiFile*/,
- CORBA::Boolean /*isASCII*/);
+ virtual char* LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
+ const char* aLocalPersistentID,
+ CORBA::Boolean isMultiFile,
+ CORBA::Boolean isASCII);
- virtual bool CanPublishInStudy(CORBA::Object_ptr /*theIOR*/);
+ virtual bool CanPublishInStudy(CORBA::Object_ptr theIOR);
- virtual SALOMEDS::SObject_ptr PublishInStudy(SALOMEDS::SObject_ptr /*theSObject*/,
- CORBA::Object_ptr /*theObject*/,
- const char* /*theName*/);
+ virtual SALOMEDS::SObject_ptr PublishInStudy(SALOMEDS::SObject_ptr theSObject,
+ CORBA::Object_ptr theObject,
+ const char* theName);
- virtual CORBA::Boolean CanCopy(SALOMEDS::SObject_ptr /*theObject*/);
+ virtual CORBA::Boolean CanCopy(SALOMEDS::SObject_ptr theObject);
- virtual SALOMEDS::TMPFile* CopyFrom(SALOMEDS::SObject_ptr /*theObject*/,
- CORBA::Long& /*theObjectID*/);
+ virtual SALOMEDS::TMPFile* CopyFrom(SALOMEDS::SObject_ptr theObject,
+ CORBA::Long& theObjectID);
- virtual CORBA::Boolean CanPaste(const char* /*theComponentName*/,
- CORBA::Long /*theObjectID*/);
+ virtual CORBA::Boolean CanPaste(const char* theComponentName,
+ CORBA::Long theObjectID);
- virtual SALOMEDS::SObject_ptr PasteInto(const SALOMEDS::TMPFile& /*theStream*/,
- CORBA::Long /*theObjectID*/,
- SALOMEDS::SObject_ptr /*theObject*/);
+ virtual SALOMEDS::SObject_ptr PasteInto(const SALOMEDS::TMPFile& theStream,
+ CORBA::Long theObjectID,
+ SALOMEDS::SObject_ptr theObject);
};
#endif
// Used by SALOME_Launcher
std::shared_ptr<ResourcesManager_cpp> _ResManager;
- virtual void notifyObservers(const std::string & event_name, const std::string & event_data) { SALOME_UNUSED(event_name); SALOME_UNUSED(event_data);}
+ virtual void notifyObservers(const std::string & /*event_name*/, const std::string & /*event_data*/) {}
int addJob(Launcher::Job * new_job);
// Methods used by user interface methods
SALOME::StringVec *ret(new SALOME::StringVec);
std::vector<std::string> loes(ListOfExternalServersCpp(_NS));
std::size_t sz(loes.size());
- ret->length((_CORBA_ULong)sz); //!< TODO: conversion from size_t to _CORBA_ULong
+ ret->length((CORBA::ULong)sz);
for(auto i = 0; i<(int)sz ; i++) //TODO: mismatch signed/unsigned
{
(*ret)[i]=CORBA::string_dup(loes[i].c_str());
t.read(buffer.get(),size);
//
std::unique_ptr<SALOME::ByteVec> ret(new SALOME::ByteVec);
- ret->length((_CORBA_ULong)size); //!< TODO: conversion from size_t to _CORBA_ULong
+ ret->length((CORBA::ULong)size);
for(std::size_t i=0;i<size;++i)
- (*ret)[(_CORBA_ULong)i] = buffer.get()[i]; //!< TODO: conversion from size_t to _CORBA_ULong
+ (*ret)[(CORBA::ULong)i] = buffer.get()[i]; //!< TODO: conversion from size_t to CORBA::ULong
//
if( unlink(file_name)!=0 )
{
result->job_file = CORBA::string_dup(job_parameters.job_file.c_str());
result->pre_command = CORBA::string_dup(job_parameters.pre_command.c_str());
result->env_file = CORBA::string_dup(job_parameters.env_file.c_str());
- result->in_files.length((_CORBA_ULong)job_parameters.in_files.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ result->in_files.length((CORBA::ULong)job_parameters.in_files.size()); //!< TODO: conversion from size_t to CORBA::ULong
int i = 0;
for(const std::string& it : job_parameters.in_files)
result->in_files[i] = CORBA::string_dup(it.c_str());
i++;
}
- result->out_files.length((_CORBA_ULong)job_parameters.out_files.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ result->out_files.length((CORBA::ULong)job_parameters.out_files.size()); //!< TODO: conversion from size_t to CORBA::ULong
i = 0;
for(const std::string& it : job_parameters.out_files)
{
= job_parameters.specific_parameters;
if (!specific_parameters.empty())
{
- result->specific_parameters.length((_CORBA_ULong)specific_parameters.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ result->specific_parameters.length((CORBA::ULong)specific_parameters.size()); //!< TODO: conversion from size_t to CORBA::ULong
CORBA::ULong i = 0;
for (const auto& it_specific : specific_parameters)
{
INCLUDE_DIRECTORIES(
${PYTHON_INCLUDE_DIRS}
${LIBBATCH_INCLUDE_DIRS}
- ${CMAKE_CURRENT_SOURCE_DIR}/../Basics
${CMAKE_CURRENT_SOURCE_DIR}/../ResourcesManager
${CMAKE_CURRENT_SOURCE_DIR}/../Launcher
)
// --- Check if containerName contains machine name (if yes: rg>0)
char *stContainer=strdup(containerName);
std::string st2Container(stContainer);
- int rg=(int)st2Container.find("/"); //!< TODO: conversion from size_t to int
+ size_t rg=st2Container.find("/");
Engines::ContainerParameters params;
preSet(params);
- if (rg<0)
+ if (rg == std::string::npos)
{
// containerName doesn't contain "/" => Local container
params.container_name = CORBA::string_dup(stContainer);
// Module : SALOME
//
#include "SALOME_Trace.hxx"
-#include "Basics_Utils.hxx"
#include <memory.h>
#include <string>
//#include <stdio.h>
return 1;
}
-void SALOME_Trace::putMessage(std::ostream& msg)
+void SALOME_Trace::putMessage(std::ostream& /*msg*/)
{
- SALOME_UNUSED(msg);
//if (!isInitialized) std::cout<<"!!! SALOME_Trace is used without initialising !!!"<<std::endl;
//write resulting string into Logger CORBA server
//concatenate string from passing parameters for transferring into Logger CORBA server
\return the wanted interface
*/
virtual SALOME_ModuleCatalog::DefinitionInterface*
- GetInterface(const char* interfacename)
- ;
+ GetInterface(const char* interfacename);
//! method to get a list of the services name of an interface of a component
/*!If the specified interface doesn't exist, the Notfound exception is thrown
\return a list of the services of the wanted interface
*/
virtual SALOME_ModuleCatalog::ListOfServices*
- GetServiceList(const char* interfacename)
- ;
+ GetServiceList(const char* interfacename);
//! method to get one service of an interface of a component
*/
virtual SALOME_ModuleCatalog::Service*
GetService(const char* interfacename,
- const char* servicename)
- ;
+ const char* servicename);
//! method to get the default service of an interface of a component
/*! If the specified interface doesn't exist, the Notfound exception is thrown
\return the default service of the interface
*/
virtual SALOME_ModuleCatalog::Service*
- GetDefaultService(const char* interfacename)
- ;
+ GetDefaultService(const char* interfacename);
//! method to get the PathPrefix of a computer
/*! If the wanted computer doesn't exist, the Notfound exception is thrown
\param machinename const char* arguments
\return the prefix path
*/
- virtual char* GetPathPrefix(const char* machinename)
- ;
+ virtual char* GetPathPrefix(const char* machinename);
//! method to obtain the constraint affected to a component
/*! to be resolved by LifeCycle for the computer choice
\return the constraint
*/
- virtual char* constraint() ;
+ virtual char* constraint();
//! method to obtain the componentname
/*!
SALOME_ModuleCatalog::ListOfTypeDefinition* SALOME_ModuleCatalogImpl::GetTypes()
{
SALOME_ModuleCatalog::ListOfTypeDefinition_var type_list = new SALOME_ModuleCatalog::ListOfTypeDefinition();
- type_list->length(static_cast<unsigned long>(myPrivate->_typeList.size()));
+ type_list->length((CORBA::ULong)myPrivate->_typeList.size());
for (unsigned int ind = 0 ; ind < myPrivate->_typeList.size() ; ind++)
{
type_list[ind].kind=SALOME_ModuleCatalog::Objref;
type_list[ind].id=CORBA::string_dup(myPrivate->_typeList[ind].id.c_str());
//bases
- type_list[ind].bases.length(static_cast<unsigned long>(myPrivate->_typeList[ind].bases.size()));
+ type_list[ind].bases.length((CORBA::ULong)myPrivate->_typeList[ind].bases.size());
std::vector<std::string>::const_iterator miter;
miter=myPrivate->_typeList[ind].bases.begin();
int n_memb=0;
{
type_list[ind].kind=SALOME_ModuleCatalog::Struc;
//members
- type_list[ind].members.length(static_cast<unsigned long>(myPrivate->_typeList[ind].members.size()));
+ type_list[ind].members.length((CORBA::ULong)myPrivate->_typeList[ind].members.size());
std::vector< std::pair<std::string,std::string> >::const_iterator miter;
miter=myPrivate->_typeList[ind].members.begin();
SALOME_ModuleCatalog::ListOfComponents_var _list_components =
new SALOME_ModuleCatalog::ListOfComponents;
- _list_components->length(static_cast<unsigned long>(myPrivate->_personal_module_list.size()));
+ _list_components->length((CORBA::ULong)myPrivate->_personal_module_list.size());
// All the components defined in the personal catalog are taken
for(unsigned int ind=0; ind < myPrivate->_personal_module_list.size();ind++){
if(MYDEBUG) SCRUTE(_list_components[ind]) ;
}
- size_t indice = static_cast<size_t>(myPrivate->_personal_module_list.size()) ;
+ size_t indice = myPrivate->_personal_module_list.size();
bool _find = false;
// The components in the general catalog are taken only if they're
if(!_find){
if(MYDEBUG) MESSAGE("A new component " << myPrivate->_general_module_list[ind].name
<< " has to be to added in the list");
- _list_components->length(static_cast<unsigned long>(indice+1));
+ _list_components->length((CORBA::ULong)indice+1);
// The component is not already defined => has to be taken
- _list_components[static_cast<unsigned long>(indice)]=(myPrivate->_general_module_list[ind].name).c_str();
- if(MYDEBUG) SCRUTE(_list_components[indice]) ;
+ _list_components[(CORBA::ULong)indice]=(myPrivate->_general_module_list[ind].name).c_str();
+ if(MYDEBUG) SCRUTE(_list_components[(CORBA::ULong)indice]) ;
indice++;
}else{
SALOME_ModuleCatalog::ListOfIAPP_Affich_var _list_components_icone =
new SALOME_ModuleCatalog::ListOfIAPP_Affich;
- _list_components_icone->length(static_cast<unsigned long>(myPrivate->_personal_module_list.size()));
+ _list_components_icone->length((CORBA::ULong)myPrivate->_personal_module_list.size());
// All the components defined in the personal catalog are taken
for(unsigned int ind=0; ind < myPrivate->_personal_module_list.size();ind++){
//if(MYDEBUG) SCRUTE(_list_components_icone[ind].moduleicone);
}
- size_t indice = myPrivate->_personal_module_list.size() ;
+ size_t indice = myPrivate->_personal_module_list.size();
bool _find = false;
// The components in the general catalog are taken only if they're
}
if(!_find){
// if(MYDEBUG) MESSAGE("A new component " << _general_module_list[ind].name << " has to be to added in the list");
- _list_components_icone->length(static_cast<unsigned long>(indice+1));
+ _list_components_icone->length((CORBA::ULong)indice+1);
// The component is not already defined => has to be taken
- _list_components_icone[static_cast<unsigned long>(indice)].modulename=myPrivate->_general_module_list[ind].name.c_str();
- _list_components_icone[static_cast<unsigned long>(indice)].moduleusername=myPrivate->_general_module_list[ind].username.c_str();
- _list_components_icone[static_cast<unsigned long>(indice)].moduleicone=myPrivate->_general_module_list[ind].icon.c_str();
- _list_components_icone[static_cast<unsigned long>(indice)].moduleversion=myPrivate->_general_module_list[ind].version.c_str();
- _list_components_icone[static_cast<unsigned long>(indice)].modulecomment=myPrivate->_general_module_list[ind].comment.c_str();
- //if(MYDEBUG) SCRUTE(_list_components_icone[indice].modulename) ;
- //if(MYDEBUG) SCRUTE(_list_components_icone[indice].moduleicone);
+ _list_components_icone[(CORBA::ULong)indice].modulename=myPrivate->_general_module_list[ind].name.c_str();
+ _list_components_icone[(CORBA::ULong)indice].moduleusername=myPrivate->_general_module_list[ind].username.c_str();
+ _list_components_icone[(CORBA::ULong)indice].moduleicone=myPrivate->_general_module_list[ind].icon.c_str();
+ _list_components_icone[(CORBA::ULong)indice].moduleversion=myPrivate->_general_module_list[ind].version.c_str();
+ _list_components_icone[(CORBA::ULong)indice].modulecomment=myPrivate->_general_module_list[ind].comment.c_str();
+ //if(MYDEBUG) SCRUTE(_list_components_icone[(CORBA::ULong)indice].modulename) ;
+ //if(MYDEBUG) SCRUTE(_list_components_icone[(CORBA::ULong)indice].moduleicone);
indice++;
}
C_corba.implname = CORBA::string_dup(C_parser.implementationName.c_str());
size_t _length = C_parser.interfaces.size();
- C_corba.interfaces.length(static_cast<unsigned long>(_length));
+ C_corba.interfaces.length((CORBA::ULong)_length);
for (unsigned int ind = 0; ind < _length; ind++)
duplicate(C_corba.interfaces[ind], C_parser.interfaces[ind]);
// if(MYDEBUG) SCRUTE(_length);
// I_corba.interfaceservicelist
// = new SALOME_ModuleCatalog::ListOfInterfaceService;
- I_corba.interfaceservicelist.length(static_cast<unsigned long>(_length));
+ I_corba.interfaceservicelist.length((CORBA::ULong)_length);
for (unsigned int ind1 = 0; ind1 < _length ; ind1 ++)
duplicate(I_corba.interfaceservicelist[ind1],
// duplicate in Parameters
_length = S_parser.inParameters.size();
- S_corba.ServiceinParameter.length(static_cast<unsigned long>(_length));
+ S_corba.ServiceinParameter.length((CORBA::ULong)_length);
for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
duplicate(S_corba.ServiceinParameter[ind2],
// duplicate out Parameters
_length = S_parser.outParameters.size();
- S_corba.ServiceoutParameter.length(static_cast<unsigned long>(_length));
+ S_corba.ServiceoutParameter.length((CORBA::ULong)_length);
for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
duplicate(S_corba.ServiceoutParameter[ind2],
// duplicate in DataStreamParameters
_length = S_parser.inDataStreamParameters.size();
- S_corba.ServiceinDataStreamParameter.length(static_cast<unsigned long>(_length));
+ S_corba.ServiceinDataStreamParameter.length((CORBA::ULong)_length);
for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
duplicate(S_corba.ServiceinDataStreamParameter[ind2],
// duplicate out DataStreamParameters
_length = S_parser.outDataStreamParameters.size();
// if(MYDEBUG) SCRUTE(_length);
- S_corba.ServiceoutDataStreamParameter.length(static_cast<unsigned long>(_length));
+ S_corba.ServiceoutDataStreamParameter.length((CORBA::ULong)_length);
for (unsigned int ind2 = 0; ind2 < _length ; ind2 ++)
duplicate(S_corba.ServiceoutDataStreamParameter[ind2],
endWithDelim = true;
if (endIdx == std::string::npos)
endIdx = path.length();
- size_t 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);
}
- size_t dim;
+ int dim;
if (onlyDir) // only directory part
{
- dim = splitPath.size()-1; // omit final object
+ 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(static_cast<unsigned long>(dim));
- for (int i=0; i<(int)dim; i++)
+ context_name.length((CORBA::ULong)dim);
+ for (int i=0; i<dim; i++)
{
// SCRUTE(splitPath[i]);
context_name[i].id = CORBA::string_dup(splitPath[i].c_str());
- if (!endWithDelim && (i == (int)dim-1)) // here, the last string is an object
+ if (!endWithDelim && (i == dim-1)) // here, the last string is an object
{
context_name[i].kind = CORBA::string_dup("object");
// MESSAGE("--- " <<splitPath[i] <<".object");
// MESSAGE("--- " <<splitPath[i] <<".dir");
}
}
- return static_cast<int>(dim); //TODO: return <int> or <size_t>?
+ return dim; //TODO: return <int> or <size_t>?
}
// ============================================================================
// Module : SALOME
//
#include "NOTIFICATION.hxx"
-#include "Basics_Utils.hxx"
NOTIFICATION_Consumer::NOTIFICATION_Consumer():
proxy_supplier(0),
void NOTIFICATION_Consumer::disconnect_structured_pull_consumer() {
}
-void NOTIFICATION_Consumer::offer_change(const CosN_EventTypeSeq& added, const CosN_EventTypeSeq& deled) {
- SALOME_UNUSED(added); SALOME_UNUSED(deled);
+void NOTIFICATION_Consumer::offer_change(const CosN_EventTypeSeq& /*added*/, const CosN_EventTypeSeq& /*deled*/) {
}
// Module : SALOME
//
#include "NOTIFICATION.hxx"
-#include "Basics_Utils.hxx"
long NOTIFICATION_Supplier::_stamp = 0;
void NOTIFICATION_Supplier::disconnect_structured_push_supplier() {
}
-void NOTIFICATION_Supplier::subscription_change(const CosN_EventTypeSeq& added, const CosN_EventTypeSeq& deled) {
- SALOME_UNUSED(added); SALOME_UNUSED(deled);
+void NOTIFICATION_Supplier::subscription_change(const CosN_EventTypeSeq& /*added*/, const CosN_EventTypeSeq& /*deled*/) {
}
const Identity lesInfos( aName ) ;
Registry::Infos infos ;
infos.name = CORBA::string_dup( lesInfos.name() ) ;
- infos.pid = lesInfos.pid() ;
- infos.machine = CORBA::string_dup( lesInfos.host_char() ) ;
+ infos.pid = lesInfos.pid() ;
+ infos.machine = CORBA::string_dup( lesInfos.host_char() ) ;
infos.adip = CORBA::string_dup( lesInfos.adip() ) ;
- infos.uid = /*(long)*/(CORBA::Long)lesInfos.uid() ; //!< TODO: pointer truncation from const PSID to long
- infos.pwname = CORBA::string_dup( lesInfos.pwname() ) ;
- infos.tc_start = (CORBA::Long)lesInfos.start() ; //!< TODO: conversation from const time_t to CORBA::Long
- infos.tc_hello = 0 ;
- infos.tc_end = 0 ;
- infos.difftime = 0 ;
+ infos.uid = (CORBA::Long)lesInfos.uid() ; //!< TODO: pointer truncation from const PSID to long
+ infos.pwname = CORBA::string_dup( lesInfos.pwname() ) ;
+ infos.tc_start = (CORBA::Long)lesInfos.start() ; //!< TODO: conversation from const time_t to CORBA::Long
+ infos.tc_hello = 0 ;
+ infos.tc_end = 0 ;
+ infos.difftime = 0 ;
infos.cdir = CORBA::string_dup( lesInfos.rep() ) ;
- infos.status = -1 ;
- infos.ior = CORBA::string_dup(_Ior);
+ infos.status = -1 ;
+ infos.ior = CORBA::string_dup(_Ior);
ASSERT(!CORBA::is_nil(this->_VarComponents)) ;
Registry::AllInfos *all = new Registry::AllInfos ;
ASSERT(all) ;
- const size_t RegLength = mymap.size();
- all->length((_CORBA_ULong)RegLength); //!< TODO: conversion from size_t to _CORBA_ULong
+ size_t RegLength = mymap.size();
+ all->length((CORBA::ULong)RegLength);
std::map<int,client_infos *>::iterator im;
for (im=mymap.begin();im!=mymap.end(); im++)
#include <map>
std::string LoadRateManagerFirst::Find(const std::vector<std::string>& hosts,
- const MapOfParserResourcesType& resList)
+ const MapOfParserResourcesType& /*resList*/)
{
- SALOME_UNUSED(resList);
if (hosts.size() == 0)
return std::string("");
}
std::string LoadRateManagerAltCycl::Find(const std::vector<std::string>& hosts,
- const MapOfParserResourcesType& resList)
+ const MapOfParserResourcesType& /*resList*/)
{
- SALOME_UNUSED(resList);
if (hosts.size() == 0)
return std::string("");
#include <string>
#include <map>
#include "SALOME_ResourcesCatalog_Parser.hxx"
-#include "Basics_Utils.hxx"
class RESOURCESMANAGER_EXPORT LoadRateManager
{
public:
- virtual std::string Find(const std::vector<std::string>& hosts, const MapOfParserResourcesType& resList) { SALOME_UNUSED(hosts); SALOME_UNUSED(resList); return ""; }
+ virtual std::string Find(const std::vector<std::string>& /*hosts*/, const MapOfParserResourcesType& /*resList*/) { return ""; }
};
class RESOURCESMANAGER_EXPORT LoadRateManagerFirst : public LoadRateManager
machines=new Engines::ResourceList;
nbProcsOfMachines=new Engines::IntegerList;
std::size_t sz(ret0.size());
- machines->length(static_cast<unsigned long>(sz)); nbProcsOfMachines->length(static_cast<unsigned long>(sz));
+ machines->length((CORBA::ULong)sz); nbProcsOfMachines->length((CORBA::ULong)sz);
for(std::size_t j=0;j<sz;j++)
{
- (*machines)[static_cast<unsigned long>(j)]=CORBA::string_dup(ret0[j].c_str());
- (*nbProcsOfMachines)[static_cast<unsigned long>(j)]=ret1[j];
+ (*machines)[(CORBA::ULong)j]=CORBA::string_dup(ret0[j].c_str());
+ (*nbProcsOfMachines)[(CORBA::ULong)j]=ret1[j];
}
}
typename T::_var_type strvec_CPPtoCORBA(const vector<string> & strvecCpp)
{
typename T::_var_type strvecCorba = new T;
- strvecCorba->length((_CORBA_ULong)strvecCpp.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ strvecCorba->length((CORBA::ULong)strvecCpp.size());
for(unsigned int i=0;i<strvecCpp.size();i++)
strvecCorba[i] = strvecCpp[i].c_str();
return strvecCorba;
*/
//=======================================================================
CORBA::Long SALOMEDS_AttributeParameter_i::GetInt(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
*/
//=======================================================================
CORBA::Double SALOMEDS_AttributeParameter_i::GetReal(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
*/
//=======================================================================
char* SALOMEDS_AttributeParameter_i::GetString(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
*/
//=======================================================================
CORBA::Boolean SALOMEDS_AttributeParameter_i::GetBool(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
*/
//=======================================================================
SALOMEDS::DoubleSeq* SALOMEDS_AttributeParameter_i::GetRealArray(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
*/
//=======================================================================
SALOMEDS::LongSeq* SALOMEDS_AttributeParameter_i::GetIntArray(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
*/
//=======================================================================
SALOMEDS::StringSeq* SALOMEDS_AttributeParameter_i::GetStrArray(const char* theID)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (AP_InvalidIdentifier);
virtual void SetInt(const char* theID, CORBA::Long theValue);
- virtual CORBA::Long GetInt(const char* theID)
- noexcept;
+ virtual CORBA::Long GetInt(const char* theID);
virtual void SetReal(const char* theID, CORBA::Double theValue);
- virtual CORBA::Double GetReal(const char* theID)
- noexcept;
+ virtual CORBA::Double GetReal(const char* theID);
virtual void SetString(const char* theID, const char* theValue);
- virtual char* GetString(const char* theID)
- noexcept;
+ virtual char* GetString(const char* theID);
virtual void SetBool(const char* theID, CORBA::Boolean theValue);
- virtual CORBA::Boolean GetBool(const char* theID)
- noexcept;
+ virtual CORBA::Boolean GetBool(const char* theID);
virtual void SetRealArray(const char* theID, const SALOMEDS::DoubleSeq& theArray);
- virtual SALOMEDS::DoubleSeq* GetRealArray(const char* theID)
- noexcept;
+ virtual SALOMEDS::DoubleSeq* GetRealArray(const char* theID);
virtual void SetIntArray(const char* theID, const SALOMEDS::LongSeq& theArray);
- virtual SALOMEDS::LongSeq* GetIntArray(const char* theID)
- noexcept;
+ virtual SALOMEDS::LongSeq* GetIntArray(const char* theID);
virtual void SetStrArray(const char* theID, const SALOMEDS::StringSeq& theArray);
- virtual SALOMEDS::StringSeq* GetStrArray(const char* theID)
- noexcept;
+ virtual SALOMEDS::StringSeq* GetStrArray(const char* theID);
virtual CORBA::Boolean IsSet(const char* theID, CORBA::Long theType);
CheckLocked();
std::vector<double> CasCadeSeq;
for (size_t i = 0; i < other.length(); i++) {
- CasCadeSeq.push_back(other[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ CasCadeSeq.push_back(other[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
}
dynamic_cast<SALOMEDSImpl_AttributeSequenceOfReal*>(_impl)->Assign(CasCadeSeq);
}
SALOMEDS::Locker lock;
std::vector<std::string> components = dynamic_cast<SALOMEDSImpl_AttributeStudyProperties*>(_impl)->GetStoredComponents();
SALOMEDS::StringSeq_var c_components = new SALOMEDS::StringSeq();
- c_components->length((_CORBA_ULong)components.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ c_components->length((CORBA::ULong)components.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)components.size(); i++) { //TODO: mismatch signed/unsigned
c_components[i] = CORBA::string_dup(components[i].c_str());
}
SALOMEDS::Locker lock;
std::vector<std::string> versions = dynamic_cast<SALOMEDSImpl_AttributeStudyProperties*>(_impl)->GetComponentVersions(theComponent);
SALOMEDS::StringSeq_var c_versions = new SALOMEDS::StringSeq();
- c_versions->length((_CORBA_ULong)versions.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ c_versions->length((CORBA::ULong)versions.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)versions.size(); i++) { //TODO: mismatch signed/unsigned
c_versions[i] = CORBA::string_dup(versions[i].c_str());
}
}
void SALOMEDS_AttributeTableOfInteger_i::SetRowTitle(CORBA::Long theIndex, const char* theTitle)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfInteger_i::GetRowTitle(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfInteger_i::SetRowTitles(const SALOMEDS::StringSeq& theTitles)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectArgumentLength);
}
void SALOMEDS_AttributeTableOfInteger_i::SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfInteger_i::GetColumnTitle(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfInteger_i::SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectArgumentLength);
//Units support
void SALOMEDS_AttributeTableOfInteger_i::SetRowUnit(CORBA::Long theIndex, const char* theUnit)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfInteger_i::GetRowUnit(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfInteger_i::SetRowUnits(const SALOMEDS::StringSeq& theUnits)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATI_IncorrectArgumentLength);
}
void SALOMEDS_AttributeTableOfInteger_i::AddRow(const SALOMEDS::LongSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfInteger*>(_impl);
std::vector<int> aRow;
- for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
try {
aTable->SetRowData(aTable->GetNbRows() + 1, aRow);
}
}
void SALOMEDS_AttributeTableOfInteger_i::SetRow(CORBA::Long theRow, const SALOMEDS::LongSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfInteger*>(_impl);
std::vector<int> aRow;
- for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
try {
aTable->SetRowData(theRow, aRow);
}
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfInteger_i::GetRow(CORBA::Long theRow)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
std::vector<int> aRow = aTable->GetRowData(theRow);
- CorbaSeq->length((_CORBA_ULong)aRow.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aRow.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < aRow.size(); i++) {
CorbaSeq[i] = aRow[i];
}
}
void SALOMEDS_AttributeTableOfInteger_i::AddColumn(const SALOMEDS::LongSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfInteger*>(_impl);
std::vector<int> aColumn;
- for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
try {
aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn);
}
}
void SALOMEDS_AttributeTableOfInteger_i::SetColumn(CORBA::Long theColumn, const SALOMEDS::LongSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfInteger*>(_impl);
std::vector<int> aColumn;
- for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
try {
aTable->SetColumnData(theColumn, aColumn);
}
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfInteger_i::GetColumn(CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
std::vector<int> aColumn = aTable->GetColumnData(theColumn);
- CorbaSeq->length((_CORBA_ULong)aColumn.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aColumn.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < aColumn.size(); i++) {
CorbaSeq[i] = aColumn[i];
}
}
void SALOMEDS_AttributeTableOfInteger_i::PutValue(CORBA::Long theValue, CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
}
CORBA::Long SALOMEDS_AttributeTableOfInteger_i::GetValue(CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfInteger_i::RemoveValue(CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
std::vector<int> aSeq = aTable->GetSetRowIndices(theRow);
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfInteger_i::SortRow(CORBA::Long theRow,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfInteger_i::SortColumn(CORBA::Long theColumn,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfInteger_i::SortByRow(CORBA::Long theRow,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfInteger_i::SortByColumn(CORBA::Long theColumn,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
void SALOMEDS_AttributeTableOfInteger_i::SwapCells(CORBA::Long theRow1, CORBA::Long theColumn1,
CORBA::Long theRow2, CORBA::Long theColumn2)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfInteger_i::SwapRows(CORBA::Long theRow1, CORBA::Long theRow2)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfInteger_i::SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATI_IncorrectIndex);
virtual void SetTitle(const char* theTitle);
virtual char* GetTitle();
- virtual void SetRowTitle(CORBA::Long theIndex, const char* theTitle)
- noexcept;
- virtual char* GetRowTitle(CORBA::Long theIndex)
- noexcept;
- virtual void SetRowTitles(const SALOMEDS::StringSeq& theTitles)
- noexcept;
+ virtual void SetRowTitle(CORBA::Long theIndex, const char* theTitle);
+ virtual char* GetRowTitle(CORBA::Long theIndex);
+ virtual void SetRowTitles(const SALOMEDS::StringSeq& theTitles);
virtual SALOMEDS::StringSeq* GetRowTitles();
- virtual void SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
- noexcept;
- virtual char* GetColumnTitle(CORBA::Long theIndex)
- noexcept;
- virtual void SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
- noexcept;
+ virtual void SetColumnTitle(CORBA::Long theIndex, const char* theTitle);
+ virtual char* GetColumnTitle(CORBA::Long theIndex);
+ virtual void SetColumnTitles(const SALOMEDS::StringSeq& theTitles);
virtual SALOMEDS::StringSeq* GetColumnTitles();
- virtual void SetRowUnit(CORBA::Long theIndex, const char* theUnit)
- noexcept;
- virtual char* GetRowUnit(CORBA::Long theIndex)
- noexcept;
- virtual void SetRowUnits(const SALOMEDS::StringSeq& theUnits)
- noexcept;
+ virtual void SetRowUnit(CORBA::Long theIndex, const char* theUnit);
+ virtual char* GetRowUnit(CORBA::Long theIndex);
+ virtual void SetRowUnits(const SALOMEDS::StringSeq& theUnits);
virtual SALOMEDS::StringSeq* GetRowUnits();
virtual CORBA::Long GetNbRows();
virtual CORBA::Long GetNbColumns();
- virtual void AddRow(const SALOMEDS::LongSeq& theData)
- noexcept;
- virtual void SetRow(CORBA::Long theRow, const SALOMEDS::LongSeq& theData)
- noexcept;
- virtual SALOMEDS::LongSeq* GetRow(CORBA::Long theRow)
- noexcept;
- virtual void AddColumn(const SALOMEDS::LongSeq& theData)
- noexcept;
- virtual void SetColumn(CORBA::Long theColumn, const SALOMEDS::LongSeq& theData)
- noexcept;
- virtual SALOMEDS::LongSeq* GetColumn(CORBA::Long theColumn)
- noexcept;
- virtual void PutValue(CORBA::Long theValue, CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
+ virtual void AddRow(const SALOMEDS::LongSeq& theData);
+ virtual void SetRow(CORBA::Long theRow, const SALOMEDS::LongSeq& theData);
+ virtual SALOMEDS::LongSeq* GetRow(CORBA::Long theRow);
+ virtual void AddColumn(const SALOMEDS::LongSeq& theData);
+ virtual void SetColumn(CORBA::Long theColumn, const SALOMEDS::LongSeq& theData);
+ virtual SALOMEDS::LongSeq* GetColumn(CORBA::Long theColumn);
+ virtual void PutValue(CORBA::Long theValue, CORBA::Long theRow, CORBA::Long theColumn);
virtual CORBA::Boolean HasValue(CORBA::Long theRow, CORBA::Long theColumn);
- virtual CORBA::Long GetValue(CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
- virtual void RemoveValue(CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
+ virtual CORBA::Long GetValue(CORBA::Long theRow, CORBA::Long theColumn);
+ virtual void RemoveValue(CORBA::Long theRow, CORBA::Long theColumn);
virtual SALOMEDS::LongSeq* GetRowSetIndices(CORBA::Long theRow);
virtual void SetNbColumns(CORBA::Long theNbColumns);
virtual SALOMEDS::LongSeq* SortRow(CORBA::Long theRow, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortColumn(CORBA::Long theColumn, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortByRow(CORBA::Long theRow, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortByColumn(CORBA::Long theColumn, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual void SwapCells(CORBA::Long theRow1, CORBA::Long theColumn1,
- CORBA::Long theRow2, CORBA::Long theColumn2)
- noexcept;
- virtual void SwapRows(CORBA::Long theRow1, CORBA::Long theRow2)
- noexcept;
- virtual void SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2)
- noexcept;
+ CORBA::Long theRow2, CORBA::Long theColumn2);
+ virtual void SwapRows(CORBA::Long theRow1, CORBA::Long theRow2);
+ virtual void SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2);
virtual bool ReadFromFile(const SALOMEDS::TMPFile& theStream);
virtual SALOMEDS::TMPFile* SaveToFile();
}
void SALOMEDS_AttributeTableOfReal_i::SetRowTitle(CORBA::Long theIndex, const char* theTitle)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfReal_i::GetRowTitle(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfReal_i::SetRowTitles(const SALOMEDS::StringSeq& theTitles)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectArgumentLength);
}
void SALOMEDS_AttributeTableOfReal_i::SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfReal_i::GetColumnTitle(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfReal_i::SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectArgumentLength);
//Units support
void SALOMEDS_AttributeTableOfReal_i::SetRowUnit(CORBA::Long theIndex, const char* theUnit)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfReal_i::GetRowUnit(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfReal_i::SetRowUnits(const SALOMEDS::StringSeq& theUnits)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATR_IncorrectArgumentLength);
}
void SALOMEDS_AttributeTableOfReal_i::AddRow(const SALOMEDS::DoubleSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
std::vector<double> aRow;
- for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetRowData(aTable->GetNbRows() + 1, aRow);
}
void SALOMEDS_AttributeTableOfReal_i::SetRow(CORBA::Long theRow, const SALOMEDS::DoubleSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
std::vector<double> aRow;
- for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aRow.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetRowData(theRow, aRow);
}
SALOMEDS::DoubleSeq* SALOMEDS_AttributeTableOfReal_i::GetRow(CORBA::Long theRow)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
SALOMEDS::DoubleSeq_var CorbaSeq = new SALOMEDS::DoubleSeq;
std::vector<double> aRow = aTable->GetRowData(theRow);
- CorbaSeq->length((_CORBA_ULong)aRow.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aRow.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < aRow.size(); i++) {
CorbaSeq[i] = aRow[i];
}
}
void SALOMEDS_AttributeTableOfReal_i::AddColumn(const SALOMEDS::DoubleSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
std::vector<double> aColumn;
- for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn);
}
void SALOMEDS_AttributeTableOfReal_i::SetColumn(CORBA::Long theColumn, const SALOMEDS::DoubleSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
std::vector<double> aColumn;
- for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(_CORBA_ULong)i]); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(theData[(CORBA::ULong)i]); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetColumnData(theColumn, aColumn);
}
SALOMEDS::DoubleSeq* SALOMEDS_AttributeTableOfReal_i::GetColumn(CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
SALOMEDS::DoubleSeq_var CorbaSeq = new SALOMEDS::DoubleSeq;
std::vector<double> aColumn = aTable->GetColumnData(theColumn);
- CorbaSeq->length((_CORBA_ULong)aColumn.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aColumn.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < aColumn.size(); i++) {
CorbaSeq[i] = aColumn[i];
}
}
void SALOMEDS_AttributeTableOfReal_i::PutValue(CORBA::Double theValue, CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
}
CORBA::Double SALOMEDS_AttributeTableOfReal_i::GetValue(CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfReal_i::RemoveValue(CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfReal_i::SortRow(CORBA::Long theRow,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfReal_i::SortColumn(CORBA::Long theColumn,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfReal_i::SortByRow(CORBA::Long theRow,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfReal_i::SortByColumn(CORBA::Long theColumn,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
void SALOMEDS_AttributeTableOfReal_i::SwapCells(CORBA::Long theRow1, CORBA::Long theColumn1,
CORBA::Long theRow2, CORBA::Long theColumn2)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfReal_i::SwapRows(CORBA::Long theRow1, CORBA::Long theRow2)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfReal_i::SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATR_IncorrectIndex);
virtual void SetTitle(const char* theTitle);
virtual char* GetTitle();
- virtual void SetRowTitle(CORBA::Long theIndex, const char* theTitle)
- noexcept;
- virtual char* GetRowTitle(CORBA::Long theIndex)
- noexcept;
- virtual void SetRowTitles(const SALOMEDS::StringSeq& theTitles)
- noexcept;
+ virtual void SetRowTitle(CORBA::Long theIndex, const char* theTitle);
+ virtual char* GetRowTitle(CORBA::Long theIndex);
+ virtual void SetRowTitles(const SALOMEDS::StringSeq& theTitles);
virtual SALOMEDS::StringSeq* GetRowTitles();
- virtual void SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
- noexcept;
- virtual char* GetColumnTitle(CORBA::Long theIndex)
- noexcept;
- virtual void SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
- noexcept;
+ virtual void SetColumnTitle(CORBA::Long theIndex, const char* theTitle);
+ virtual char* GetColumnTitle(CORBA::Long theIndex);
+ virtual void SetColumnTitles(const SALOMEDS::StringSeq& theTitles);
virtual SALOMEDS::StringSeq* GetColumnTitles();
- virtual void SetRowUnit(CORBA::Long theIndex, const char* theUnit)
- noexcept;
- virtual char* GetRowUnit(CORBA::Long theIndex)
- noexcept;
- virtual void SetRowUnits(const SALOMEDS::StringSeq& theUnits)
- noexcept;
+ virtual void SetRowUnit(CORBA::Long theIndex, const char* theUnit);
+ virtual char* GetRowUnit(CORBA::Long theIndex);
+ virtual void SetRowUnits(const SALOMEDS::StringSeq& theUnits);
virtual SALOMEDS::StringSeq* GetRowUnits();
virtual CORBA::Long GetNbRows();
virtual CORBA::Long GetNbColumns();
- virtual void AddRow(const SALOMEDS::DoubleSeq& theData)
- noexcept;
- virtual void SetRow(CORBA::Long theRow, const SALOMEDS::DoubleSeq& theData)
- noexcept;
- virtual SALOMEDS::DoubleSeq* GetRow(CORBA::Long theRow)
- noexcept;
- virtual void AddColumn(const SALOMEDS::DoubleSeq& theData)
- noexcept;
- virtual void SetColumn(CORBA::Long theColumn, const SALOMEDS::DoubleSeq& theData)
- noexcept;
- virtual SALOMEDS::DoubleSeq* GetColumn(CORBA::Long theColumn)
- noexcept;
- virtual void PutValue(CORBA::Double theValue, CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
+ virtual void AddRow(const SALOMEDS::DoubleSeq& theData);
+ virtual void SetRow(CORBA::Long theRow, const SALOMEDS::DoubleSeq& theData);
+ virtual SALOMEDS::DoubleSeq* GetRow(CORBA::Long theRow);
+ virtual void AddColumn(const SALOMEDS::DoubleSeq& theData);
+ virtual void SetColumn(CORBA::Long theColumn, const SALOMEDS::DoubleSeq& theData);
+ virtual SALOMEDS::DoubleSeq* GetColumn(CORBA::Long theColumn);
+ virtual void PutValue(CORBA::Double theValue, CORBA::Long theRow, CORBA::Long theColumn);
virtual CORBA::Boolean HasValue(CORBA::Long theRow, CORBA::Long theColumn);
- virtual CORBA::Double GetValue(CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
- virtual void RemoveValue(CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
+ virtual CORBA::Double GetValue(CORBA::Long theRow, CORBA::Long theColumn);
+ virtual void RemoveValue(CORBA::Long theRow, CORBA::Long theColumn);
virtual SALOMEDS::LongSeq* GetRowSetIndices(CORBA::Long theRow);
virtual void SetNbColumns(CORBA::Long theNbColumns);
virtual SALOMEDS::LongSeq* SortRow(CORBA::Long theRow, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortColumn(CORBA::Long theColumn, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortByRow(CORBA::Long theRow, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortByColumn(CORBA::Long theColumn, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual void SwapCells(CORBA::Long theRow1, CORBA::Long theColumn1,
- CORBA::Long theRow2, CORBA::Long theColumn2)
- noexcept;
- virtual void SwapRows(CORBA::Long theRow1, CORBA::Long theRow2)
- noexcept;
- virtual void SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2)
- noexcept;
+ CORBA::Long theRow2, CORBA::Long theColumn2);
+ virtual void SwapRows(CORBA::Long theRow1, CORBA::Long theRow2);
+ virtual void SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2);
virtual bool ReadFromFile(const SALOMEDS::TMPFile& theStream);
virtual SALOMEDS::TMPFile* SaveToFile();
}
void SALOMEDS_AttributeTableOfString_i::SetRowTitle(CORBA::Long theIndex, const char* theTitle)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfString_i::GetRowTitle(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATS_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfString_i::SetRowTitles(const SALOMEDS::StringSeq& theTitles)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
}
void SALOMEDS_AttributeTableOfString_i::SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfString_i::GetColumnTitle(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATS_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfString_i::SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
//Units support
void SALOMEDS_AttributeTableOfString_i::SetRowUnit(CORBA::Long theIndex, const char* theUnit)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfString_i::GetRowUnit(CORBA::Long theIndex)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch (ATS_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfString_i::SetRowUnits(const SALOMEDS::StringSeq& theUnits)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
}
void SALOMEDS_AttributeTableOfString_i::AddRow(const SALOMEDS::StringSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfString* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfString*>(_impl);
std::vector<std::string> aRow;
- for (size_t i = 0; i < theData.length(); i++) aRow.push_back(std::string(CORBA::string_dup(theData[(_CORBA_ULong)i]))); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aRow.push_back(std::string(CORBA::string_dup(theData[(CORBA::ULong)i]))); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetRowData(aTable->GetNbRows() + 1, aRow);
}
void SALOMEDS_AttributeTableOfString_i::SetRow(CORBA::Long theRow, const SALOMEDS::StringSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfString* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfString*>(_impl);
std::vector<std::string> aRow;
- for (size_t i = 0; i < theData.length(); i++) aRow.push_back(std::string(CORBA::string_dup(theData[(_CORBA_ULong)i].in()))); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aRow.push_back(std::string(CORBA::string_dup(theData[(CORBA::ULong)i].in()))); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetRowData(theRow, aRow);
}
SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRow(CORBA::Long theRow)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
SALOMEDS::StringSeq_var CorbaSeq = new SALOMEDS::StringSeq;
std::vector<std::string> aRow = aTable->GetRowData(theRow);
- CorbaSeq->length((_CORBA_ULong)aRow.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aRow.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aRow.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = CORBA::string_dup(aRow[i].c_str());
}
}
void SALOMEDS_AttributeTableOfString_i::AddColumn(const SALOMEDS::StringSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfString* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfString*>(_impl);
std::vector<std::string> aColumn;
- for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(std::string(CORBA::string_dup(theData[(_CORBA_ULong)i]))); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(std::string(CORBA::string_dup(theData[(CORBA::ULong)i]))); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn);
}
void SALOMEDS_AttributeTableOfString_i::SetColumn(CORBA::Long theColumn, const SALOMEDS::StringSeq& theData)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectArgumentLength);
SALOMEDSImpl_AttributeTableOfString* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfString*>(_impl);
std::vector<std::string> aColumn;
- for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(std::string(CORBA::string_dup(theData[(_CORBA_ULong)i]))); //!< TODO: conversion from size_t to _CORBA_ULong
+ for (size_t i = 0; i < theData.length(); i++) aColumn.push_back(std::string(CORBA::string_dup(theData[(CORBA::ULong)i]))); //!< TODO: conversion from size_t to CORBA::ULong
aTable->SetColumnData(theColumn, aColumn);
}
SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetColumn(CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
SALOMEDS::StringSeq_var CorbaSeq = new SALOMEDS::StringSeq;
std::vector<std::string> aColumn = aTable->GetColumnData(theColumn);
- CorbaSeq->length((_CORBA_ULong)aColumn.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aColumn.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aColumn.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = CORBA::string_dup(aColumn[i].c_str());
}
}
void SALOMEDS_AttributeTableOfString_i::PutValue(const char* theValue, CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
char* SALOMEDS_AttributeTableOfString_i::GetValue(CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfString_i::RemoveValue(CORBA::Long theRow, CORBA::Long theColumn)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
std::vector<int> aSeq = aTable->GetSetRowIndices(theRow);
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfString_i::SortRow(CORBA::Long theRow,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfString_i::SortColumn(CORBA::Long theColumn,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfString_i::SortByRow(CORBA::Long theRow,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfString_i::SortByColumn(CORBA::Long theColumn,
SALOMEDS::AttributeTable::SortOrder sortOrder,
SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
catch(...) {
throw SALOMEDS::AttributeTable::IncorrectIndex();
}
- CorbaSeq->length((_CORBA_ULong)aSeq.size()); //!< TODO: conversion from size_t to _CORBA_ULong
+ CorbaSeq->length((CORBA::ULong)aSeq.size()); //!< TODO: conversion from size_t to CORBA::ULong
for (int i = 0; i < (int)aSeq.size(); i++) { //TODO: mismatch signed/unsigned
CorbaSeq[i] = aSeq[i];
}
void SALOMEDS_AttributeTableOfString_i::SwapCells(CORBA::Long theRow1, CORBA::Long theColumn1,
CORBA::Long theRow2, CORBA::Long theColumn2)
- noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfString_i::SwapRows(CORBA::Long theRow1, CORBA::Long theRow2)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
}
void SALOMEDS_AttributeTableOfString_i::SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(ATS_IncorrectIndex);
virtual void SetTitle(const char* theTitle);
virtual char* GetTitle();
- virtual void SetRowTitle(CORBA::Long theIndex, const char* theTitle)
- noexcept;
- virtual char* GetRowTitle(CORBA::Long theIndex)
- noexcept;
- virtual void SetRowTitles(const SALOMEDS::StringSeq& theTitles)
- noexcept;
+ virtual void SetRowTitle(CORBA::Long theIndex, const char* theTitle);
+ virtual char* GetRowTitle(CORBA::Long theIndex);
+ virtual void SetRowTitles(const SALOMEDS::StringSeq& theTitles);
virtual SALOMEDS::StringSeq* GetRowTitles();
- virtual void SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
- noexcept;
- virtual char* GetColumnTitle(CORBA::Long theIndex)
- noexcept;
- virtual void SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
- noexcept;
+ virtual void SetColumnTitle(CORBA::Long theIndex, const char* theTitle);
+ virtual char* GetColumnTitle(CORBA::Long theIndex);
+ virtual void SetColumnTitles(const SALOMEDS::StringSeq& theTitles);
virtual SALOMEDS::StringSeq* GetColumnTitles();
- virtual void SetRowUnit(CORBA::Long theIndex, const char* theUnit)
- noexcept;
- virtual char* GetRowUnit(CORBA::Long theIndex)
- noexcept;
- virtual void SetRowUnits(const SALOMEDS::StringSeq& theUnits)
- noexcept;
+ virtual void SetRowUnit(CORBA::Long theIndex, const char* theUnit);
+ virtual char* GetRowUnit(CORBA::Long theIndex);
+ virtual void SetRowUnits(const SALOMEDS::StringSeq& theUnits);
virtual SALOMEDS::StringSeq* GetRowUnits();
virtual CORBA::Long GetNbRows();
virtual CORBA::Long GetNbColumns();
- virtual void AddRow(const SALOMEDS::StringSeq& theData)
- noexcept;
- virtual void SetRow(CORBA::Long theRow, const SALOMEDS::StringSeq& theData)
- noexcept;
- virtual SALOMEDS::StringSeq* GetRow(CORBA::Long theRow)
- noexcept;
- virtual void AddColumn(const SALOMEDS::StringSeq& theData)
- noexcept;
- virtual void SetColumn(CORBA::Long theColumn, const SALOMEDS::StringSeq& theData)
- noexcept;
- virtual SALOMEDS::StringSeq* GetColumn(CORBA::Long theColumn)
- noexcept;
- virtual void PutValue(const char* theValue, CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
+ virtual void AddRow(const SALOMEDS::StringSeq& theData);
+ virtual void SetRow(CORBA::Long theRow, const SALOMEDS::StringSeq& theData);
+ virtual SALOMEDS::StringSeq* GetRow(CORBA::Long theRow);
+ virtual void AddColumn(const SALOMEDS::StringSeq& theData);
+ virtual void SetColumn(CORBA::Long theColumn, const SALOMEDS::StringSeq& theData);
+ virtual SALOMEDS::StringSeq* GetColumn(CORBA::Long theColumn);
+ virtual void PutValue(const char* theValue, CORBA::Long theRow, CORBA::Long theColumn);
virtual CORBA::Boolean HasValue(CORBA::Long theRow, CORBA::Long theColumn);
- virtual char* GetValue(CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
- virtual void RemoveValue(CORBA::Long theRow, CORBA::Long theColumn)
- noexcept;
+ virtual char* GetValue(CORBA::Long theRow, CORBA::Long theColumn);
+ virtual void RemoveValue(CORBA::Long theRow, CORBA::Long theColumn);
virtual SALOMEDS::LongSeq* GetRowSetIndices(CORBA::Long theRow);
virtual void SetNbColumns(CORBA::Long theNbColumns);
virtual SALOMEDS::LongSeq* SortRow(CORBA::Long theRow, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortColumn(CORBA::Long theColumn, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortByRow(CORBA::Long theRow, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual SALOMEDS::LongSeq* SortByColumn(CORBA::Long theColumn, SALOMEDS::AttributeTable::SortOrder sortOrder,
- SALOMEDS::AttributeTable::SortPolicy sortPolicy)
- noexcept;
+ SALOMEDS::AttributeTable::SortPolicy sortPolicy);
virtual void SwapCells(CORBA::Long theRow1, CORBA::Long theColumn1,
- CORBA::Long theRow2, CORBA::Long theColumn2)
- noexcept;
- virtual void SwapRows(CORBA::Long theRow1, CORBA::Long theRow2)
- noexcept;
- virtual void SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2)
- noexcept;
+ CORBA::Long theRow2, CORBA::Long theColumn2);
+ virtual void SwapRows(CORBA::Long theRow1, CORBA::Long theRow2);
+ virtual void SwapColumns(CORBA::Long theColumn1, CORBA::Long theColumn2);
virtual bool ReadFromFile(const SALOMEDS::TMPFile& theStream);
virtual SALOMEDS::TMPFile* SaveToFile();
BasicAttributeFactory() {};
virtual ~BasicAttributeFactory() {};
- SALOMEDS_BasicAttribute_i* Create(const char* type)
- ;
+ SALOMEDS_BasicAttribute_i* Create(const char* type);
};
#endif
return PortableServer::POA::_duplicate(myPOA);
}
-void SALOMEDS_GenericAttribute_i::CheckLocked() noexcept
+void SALOMEDS_GenericAttribute_i::CheckLocked()
{
SALOMEDS::Locker lock;
Unexpect aCatch(GALockProtection);
virtual PortableServer::POA_ptr _default_POA();
- void CheckLocked() noexcept;
+ void CheckLocked();
virtual char* Type();
*/
//============================================================================
void SALOMEDS_StudyBuilder_i::LoadWith(SALOMEDS::SComponent_ptr anSCO,
- SALOMEDS::Driver_ptr aDriver) noexcept
+ SALOMEDS::Driver_ptr aDriver)
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBSalomeException);
* Purpose :
*/
//============================================================================
-void SALOMEDS_StudyBuilder_i::CommitCommand() noexcept
+void SALOMEDS_StudyBuilder_i::CommitCommand()
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
* Purpose :
*/
//============================================================================
-void SALOMEDS_StudyBuilder_i::Undo() noexcept
+void SALOMEDS_StudyBuilder_i::Undo()
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
* Purpose :
*/
//============================================================================
-void SALOMEDS_StudyBuilder_i::Redo() noexcept
+void SALOMEDS_StudyBuilder_i::Redo()
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
* Purpose :
*/
//============================================================================
-void SALOMEDS_StudyBuilder_i::CheckLocked() noexcept
+void SALOMEDS_StudyBuilder_i::CheckLocked()
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
*/
//============================================================================
void SALOMEDS_StudyBuilder_i::SetName(SALOMEDS::SObject_ptr theSO, const char* theValue)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
*/
//============================================================================
void SALOMEDS_StudyBuilder_i::SetComment(SALOMEDS::SObject_ptr theSO, const char* theValue)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
*/
//============================================================================
void SALOMEDS_StudyBuilder_i::SetIOR(SALOMEDS::SObject_ptr theSO, const char* theValue)
-noexcept
{
SALOMEDS::Locker lock;
Unexpect aCatch(SBLockProtection);
*/
virtual SALOMEDS::SObject_ptr NewObjectToTag(SALOMEDS::SObject_ptr theFatherObject, CORBA::Long atag);
- virtual void LoadWith(SALOMEDS::SComponent_ptr sco, SALOMEDS::Driver_ptr Engine)
- noexcept;
+ virtual void LoadWith(SALOMEDS::SComponent_ptr sco, SALOMEDS::Driver_ptr Engine);
virtual void Load(SALOMEDS::SObject_ptr sco);
virtual void RemoveObject(SALOMEDS::SObject_ptr anObject);
virtual bool IsGUID(SALOMEDS::SObject_ptr anObject, const char* theGUID);
virtual void NewCommand();
- virtual void CommitCommand() noexcept;
+ virtual void CommitCommand();
virtual CORBA::Boolean HasOpenCommand();
virtual void AbortCommand();
- virtual void Undo() noexcept;
- virtual void Redo() noexcept;
+ virtual void Undo();
+ virtual void Redo();
CORBA::Boolean GetAvailableUndos();
CORBA::Boolean GetAvailableRedos();
CORBA::Boolean IsSaved();
virtual CORBA::Long UndoLimit();
virtual void UndoLimit(CORBA::Long);
- void CheckLocked() noexcept;
+ void CheckLocked();
- virtual void SetName(SALOMEDS::SObject_ptr theSO, const char* theValue) noexcept;
- virtual void SetComment(SALOMEDS::SObject_ptr theSO, const char* theValue) noexcept;
- virtual void SetIOR(SALOMEDS::SObject_ptr theSO, const char* theValue) noexcept;
+ virtual void SetName(SALOMEDS::SObject_ptr theSO, const char* theValue);
+ virtual void SetComment(SALOMEDS::SObject_ptr theSO, const char* theValue);
+ virtual void SetIOR(SALOMEDS::SObject_ptr theSO, const char* theValue);
SALOMEDSImpl_StudyBuilder* GetImpl() { return _impl; }
\param char* arguments, the study URL
\return bool arguments
*/
- virtual bool Open(const wchar_t* aStudyUrl) ;
+ virtual bool Open(const wchar_t* aStudyUrl);
//! method to check that a Study can be opened
/*!
/*!
\param theObject object to paste
*/
- virtual SALOMEDS::SObject_ptr Paste(SALOMEDS::SObject_ptr theObject) ;
+ virtual SALOMEDS::SObject_ptr Paste(SALOMEDS::SObject_ptr theObject);
virtual CORBA::Boolean CanPaste(SALOMEDS::SObject_ptr theObject);
//! method to Get persistent reference of study (idem URL())
\return ListOfSObject_ptr arguments, a list of objects found
*/
- virtual SALOMEDS::Study::ListOfSObject* FindObjectByName( const char* anObjectName, const char* aComponentName ) ;
+ virtual SALOMEDS::Study::ListOfSObject* FindObjectByName( const char* anObjectName, const char* aComponentName );
//! method to Find an Object with ID = anObjectID
/*!
void EnableUseCaseAutoFilling(CORBA::Boolean isEnabled);
// postponed destroying of CORBA object functionality
- virtual void AddPostponed(const char* /*theIOR*/);
+ virtual void AddPostponed(const char* theIOR);
- virtual void AddCreatedPostponed(const char* /*theIOR*/);
+ virtual void AddCreatedPostponed(const char* theIOR);
virtual void RemovePostponed(CORBA::Long theUndoLimit); // removes postponed IORs of old transaction
- // if theUndoLimit==0, removes all
- virtual void UndoPostponed(CORBA::Long /*theWay*/); // theWay = 1: resurrect objects,
- // theWay = -1: get back to the list of postponed
+ // if theUndoLimit==0, removes all
+ virtual void UndoPostponed(CORBA::Long theWay); // theWay = 1: resurrect objects,
+ // theWay = -1: get back to the list of postponed
virtual SALOMEDS::AttributeParameter_ptr GetCommonParameters(const char* theID, CORBA::Long theSavePoint);
virtual SALOMEDS::AttributeParameter_ptr GetModuleParameters(const char* theID,
if(theIndex < 0 || theIndex >= myStream->length())
throw std::out_of_range("SALOMEDS_TMPFile_i::Get(size_t) const - theIndex < 0 || theIndex >= myStream->length()");
- return myStream[(_CORBA_ULong)theIndex]; //!< TODO: conversion from size_t to _CORBA_ULong
+ return myStream[(CORBA::ULong)theIndex]; //!< TODO: conversion from size_t to CORBA::ULong
}
if(theIndex < 0 || theIndex >= myStream->length())
throw std::out_of_range("Engines_TMPFile_i::Get(size_t) const - theIndex < 0 || theIndex >= myStream->length()");
- return myStream[(_CORBA_ULong)theIndex]; //!< TODO: conversion from size_t to _CROBA_ULong
+ return myStream[(CORBA::ULong)theIndex]; //!< TODO: conversion from size_t to _CROBA_ULong
}
{
std::string aString(theString);
size_t aPos = aString.find(SEPARATOR);
- if(aPos <= 0 || aPos == aString.size() ) return std::string();
- return aString.substr(aPos+1, aString.size());
+ return aPos >= aString.size()-1 ? std::string() : aString.substr(aPos+1);
}
static std::string getTitle(std::string theString)
{
std::string aString(theString);
size_t aPos = aString.find(SEPARATOR);
- if(aPos < 1) return aString;
- if(aPos == 0) return std::string();
- return aString.substr(0, aPos);
+ return aPos == std::string::npos ? aString : aString.substr(0, aPos);
}
const std::string& SALOMEDSImpl_AttributeTableOfInteger::GetID()
{
std::string aString(theString);
size_t aPos = aString.find(SEPARATOR);
- return aPos < 0 || aPos == aString.size()-1 ? std::string() : aString.substr(aPos+1, aString.size());
+ return aPos >= aString.size()-1 ? std::string() : aString.substr(aPos+1);
}
static std::string getTitle(const std::string& theString)
{
std::string aString(theString);
size_t aPos = aString.find(SEPARATOR);
- return aPos < 0 ? aString :aString.substr(0, aPos);
+ return aPos == std::string::npos ? aString : aString.substr(0, aPos);
}
const std::string& SALOMEDSImpl_AttributeTableOfReal::GetID()
{
std::string aString(theString);
size_t aPos = aString.find(SEPARATOR);
- if(aPos <= 0 || aPos == aString.size() ) return std::string();
- return aString.substr(aPos+1, aString.size());
+ return aPos >= aString.size()-1 ? std::string() : aString.substr(aPos+1);
}
static std::string getTitle(std::string theString)
{
std::string aString(theString);
size_t aPos = aString.find(SEPARATOR);
- if(aPos < 1) return aString;
- if(aPos == 0) return std::string();
- return aString.substr(0, aPos);
+ return aPos == std::string::npos ? aString : aString.substr(0, aPos);
}
const std::string& SALOMEDSImpl_AttributeTableOfString::GetID()
std::string SALOMEDSImpl_IParameters::decodeEntry(const std::string& entry)
{
size_t pos = entry.rfind("_");
- if(pos < 0 || pos >= entry.size()) return entry;
+ if(pos >= entry.size()) return entry;
std::string compName(entry, 0, pos), compID, tail(entry, pos+1, entry.length()-1);
hasModuleData = true;
unsigned char* aStreamFile = NULL;
- size_t aStreamSize = 0;
+ long aStreamSize = 0;
if (hdf_sco_group->ExistInternalObject("FILE_STREAM")) {
HDFdataset *hdf_dataset = new HDFdataset("FILE_STREAM", hdf_sco_group);
hdf_dataset->OpenOnDisk();
- aStreamSize = (size_t)hdf_dataset->GetSize();
+ aStreamSize = hdf_dataset->GetSize();
aStreamFile = new unsigned char[aStreamSize];
if(aStreamFile == NULL) throw HDFexception("Unable to open dataset FILE_STREAM");
hdf_dataset->ReadFromDisk(aStreamFile);
bool aResult = true;
if(aStreamFile && aStreamSize > 0 ) {
aResult = (ASCIIfileState[0]=='A')?
- aDriver->LoadASCII(anSCO, aStreamFile, (long)aStreamSize, aDir.c_str(), aMultifileState[0]=='M'): //!< TODO: conversion from size_t to const long
- aDriver->Load(anSCO, aStreamFile, (long)aStreamSize, aDir.c_str(), aMultifileState[0]=='M'); //!< TODO: conversion from size_t to const long
+ aDriver->LoadASCII(anSCO, aStreamFile, aStreamSize, aDir.c_str(), aMultifileState[0]=='M'): //!< TODO: conversion from size_t to const long
+ aDriver->Load(anSCO, aStreamFile, aStreamSize, aDir.c_str(), aMultifileState[0]=='M'); //!< TODO: conversion from size_t to const long
}
if(aStreamFile != NULL) delete []aStreamFile;
//#define _DEVDEBUG_
#include "FileTraceCollector.hxx"
-#include "Basics_Utils.hxx"
// Class attributes initialisation, for class method FileTraceCollector::run
*/
// ============================================================================
-void* FileTraceCollector::run(void *bid)
+void* FileTraceCollector::run(void* /*bid*/)
{
- SALOME_UNUSED(bid);
//DEVTRACE("init run");
_threadId = new pthread_t;
*_threadId = pthread_self();
#include <fstream>
#include <cstdlib>
-#include "Basics_Utils.hxx"
#include "LocalTraceCollector.hxx"
// ============================================================================
*/
// ============================================================================
-void* LocalTraceCollector::run(void *bid)
+void* LocalTraceCollector::run(void* /*bid*/)
{
- SALOME_UNUSED(bid);
_threadId = new pthread_t;
*_threadId = pthread_self();
sem_post(&_sem); // unlock instance
${PYTHON_INCLUDE_DIRS}
${PROJECT_BINARY_DIR}/idl
${PROJECT_BINARY_DIR}/salome_adm
- ${CMAKE_CURRENT_SOURCE_DIR}/../Basics
${CMAKE_CURRENT_SOURCE_DIR}/../Utils
${CMAKE_CURRENT_SOURCE_DIR}/../NamingService
${CMAKE_CURRENT_SOURCE_DIR}/../Launcher
{
SALOME::StringVec *ret(new SALOME::StringVec);
std::size_t sz(_vars.size());
- ret->length((_CORBA_ULong)sz); //!< TODO: size_t to _CORBA_ULong
+ ret->length((CORBA::ULong)sz); //!< TODO: size_t to CORBA::ULong
std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it(_vars.begin());
for(std::size_t i=0;i<sz;it++,i++)
{
BasicDataServer *obj((*it).second);
std::string name(obj->getVarNameCpp());
- (*ret)[(_CORBA_ULong)i]=CORBA::string_dup(name.c_str()); //!< TODO: size_t to _CORBA_ULong
+ (*ret)[(CORBA::ULong)i]=CORBA::string_dup(name.c_str()); //!< TODO: size_t to CORBA::ULong
}
return ret;
}
}
Py_ssize_t sz(PyList_Size(keys));
SALOME::SeqOfByteVec *ret(new SALOME::SeqOfByteVec);
- ret->length((_CORBA_ULong)sz); //!< TODO: convert Py_ssize_t in _CORBA_ULong
+ ret->length((CORBA::ULong)sz); //!< TODO: convert Py_ssize_t in CORBA::ULong
for(Py_ssize_t i=0;i<sz;i++)
{
PyObject *item(PyList_GetItem(keys,i));
Py_XINCREF(item);
std::string pickel(varc->pickelize(item));//item consumed
- PickelizedPyObjServer::FromCppToByteSeq(pickel,(*ret)[(_CORBA_ULong)i]); //!< TODO: convert Py_ssize_t in _CORBA_ULong
+ PickelizedPyObjServer::FromCppToByteSeq(pickel,(*ret)[(CORBA::ULong)i]); //!< TODO: convert Py_ssize_t in CORBA::ULong
}
Py_XDECREF(keys);
return ret;
Transaction *elt(0);
try
{
- eltBase=_poa->reference_to_servant(transactions[(_CORBA_ULong)i]); //!< TODO: size_t to _CORBA_ULong
+ eltBase=_poa->reference_to_servant(transactions[(CORBA::ULong)i]); //!< TODO: size_t to CORBA::ULong
elt=dynamic_cast<Transaction *>(eltBase);
}
catch(...)
std::vector<std::string> scopes(listOfScopesCpp());
SALOME::StringVec *ret(new SALOME::StringVec);
std::size_t sz(scopes.size());
- ret->length((_CORBA_ULong)sz); //!< TODO: size_t to _CORBA_ULong
+ ret->length((CORBA::ULong)sz); //!< TODO: size_t to CORBA::ULong
for(std::size_t i=0;i<sz;i++)
- (*ret)[(_CORBA_ULong)i]=CORBA::string_dup(scopes[i].c_str()); //!< TODO: size_t to _CORBA_ULong
+ (*ret)[(CORBA::ULong)i]=CORBA::string_dup(scopes[i].c_str()); //!< TODO: size_t to CORBA::ULong
return ret;
}
//
SALOME::StringVec *ret(new SALOME::StringVec);
sz=retCpp.size();
- ret->length((_CORBA_ULong)sz); //!< TODO: size_t to _CORBA_ULong
+ ret->length((CORBA::ULong)sz); //!< TODO: size_t to CORBA::ULong
for(std::size_t i=0;i<sz;i++)
- (*ret)[(_CORBA_ULong)i]=CORBA::string_dup(retCpp[i].c_str()); //!< TODO: size_t to _CORBA_ULong
+ (*ret)[(CORBA::ULong)i]=CORBA::string_dup(retCpp[i].c_str()); //!< TODO: size_t to CORBA::ULong
return ret;
}
ret.resize(sz,' ');
char *buf(const_cast<char *>(ret.c_str()));
for(std::size_t i=0;i<sz;i++)
- buf[i]=bsToBeConv[(_CORBA_ULong)i]; //!< TODO: size_t to _CORBA_ULong
+ buf[i]=bsToBeConv[(CORBA::ULong)i]; //!< TODO: size_t to CORBA::ULong
}
void PickelizedPyObjServer::FromCppToByteSeq(const std::string& strToBeConv, SALOME::ByteVec& ret)
{
const char *buf(strToBeConv.c_str());
std::size_t sz(strToBeConv.size());
- ret.length((_CORBA_ULong)sz); //!< TODO: size_t to _CORBA_ULong
+ ret.length((CORBA::ULong)sz); //!< TODO: size_t to CORBA::ULong
for(std::size_t i=0;i<sz;i++)
- ret[(_CORBA_ULong)i]=buf[i]; //!< TODO: size_t to _CORBA_ULong
+ ret[(CORBA::ULong)i]=buf[i]; //!< TODO: size_t to CORBA::ULong
}
SALOME::ByteVec *PickelizedPyObjServer::FromCppToByteSeq(const std::string& strToBeConv)
// Author : Anthony GEAY (EDF R&D)
#include "SALOMESDS_RefCountServ.hxx"
-#include "Basics_Utils.hxx"
using namespace SALOMESDS;
ret.resize(sz);
unsigned char *buf(const_cast<unsigned char *>(&ret[0]));
for(std::size_t i=0;i<sz;i++)
- buf[i]=bsToBeConv[(_CORBA_ULong)i]; //!< TODO: size_t to _CORBA_ULong
+ buf[i]=bsToBeConv[(CORBA::ULong)i]; //!< TODO: size_t to CORBA::ULong
}
void Transaction::FromVBToByteSeq(const std::vector<unsigned char>& bsToBeConv, SALOME::ByteVec& ret)
{
std::size_t sz(bsToBeConv.size());
- ret.length((_CORBA_ULong)sz); //!< TODO: size_t to _CORBA_ULong
+ ret.length((CORBA::ULong)sz); //!< TODO: size_t to CORBA::ULong
for(std::size_t i=0;i<sz;i++)
- ret[(_CORBA_ULong)i]=bsToBeConv[i]; //!< TODO: size_t to _CORBA_ULong
+ ret[(CORBA::ULong)i]=bsToBeConv[i]; //!< TODO: size_t to CORBA::ULong
}
Transaction::~Transaction()
// $Header$
//
#include <SALOMEconfig.h>
-#include "Basics_Utils.hxx"
#include <iostream>
#include <sstream>
*/
// ============================================================================
-void* SALOMETraceCollector::run(void *bid)
+void* SALOMETraceCollector::run(void* /*bid*/)
{
- SALOME_UNUSED(bid);
_threadId = new pthread_t;
*_threadId = pthread_self();
sem_post(&_sem); // unlock instance
//Put a file name to aFileName
memcpy(aFileName, (aBuffer + aCurrentPos), aFileNameSize);
#ifdef WIN32
- for (i = 0; i < strlen(aFileName); i++)
+ for (int j = 0; j < strlen(aFileName); j++)
{
- if (aFileName[i] == ':')
- aFileName[i] = '_';
+ if (aFileName[j] == ':')
+ aFileName[j] = '_';
}
#endif
aCurrentPos += aFileNameSize;
std::string aPath = thePath;
bool isFound = false;
size_t pos = aPath.rfind('/');
- if(pos > 0) {
+ if(pos != std::string::npos) {
aPath = aPath.substr(pos+1, aPath.size());
isFound = true;
}
if(!isFound) {
pos = aPath.rfind('\\');
- if(pos > 0) {
+ if(pos != std::string::npos) {
aPath = aPath.substr(pos+1, aPath.size());
isFound = true;
}
}
if(!isFound) {
pos = aPath.rfind('|');
- if(pos > 0) aPath = aPath.substr(pos+1, aPath.size());
+ if(pos != std::string::npos) aPath = aPath.substr(pos+1, aPath.size());
}
pos = aPath.rfind('.');
- if(pos > 0) aPath = aPath.substr(0, pos); //Remove extension
+ if(pos != std::string::npos) aPath = aPath.substr(0, pos); //Remove extension
return aPath;
}
size_t pos = thePath.rfind('/');
std::string path;
- if(pos > 0) {
+ if(pos != std::string::npos) {
path = thePath.substr(0, pos+1);
}
if(path.empty()) {
pos = thePath.rfind('\\');
- if(pos > 0) path = thePath.substr(0, pos+1);
+ if(pos != std::string::npos) path = thePath.substr(0, pos+1);
}
if(path.empty()) {
pos = thePath.rfind('|');
- if(pos > 0) path = thePath.substr(0, pos+1);
+ if(pos != std::string::npos) path = thePath.substr(0, pos+1);
}
if(path.empty()) {
path = thePath+"/";
}
-CommException::~CommException()
+CommException::~CommException() noexcept
{
}
CommException( void );
CommException( const char *texte );
CommException( const CommException &ex );
- ~CommException();
+ ~CommException() noexcept;
} ;
# endif /* # if ( !defined __Utils_CommException_H__ ) */
//CCRT
assert(Destructeurs) ;
Destructeurs->push_back( &objet ) ;
- return static_cast<const int>(Destructeurs->size()) ; //TODO: return <const int> or <size_t>?
+ return (int)Destructeurs->size() ; //TODO: return <const int> or <size_t>?
}
