{
std::string tmp_str = file_path;
auto pos = file_path.rfind( _separator_ );
- if ( pos >= 0 )
- tmp_str = pos < (int)file_path.size()-1 ? file_path.substr( pos+1 ) : "";
+ if ( pos >= 0 ) // TODO: always true
+ tmp_str = pos < file_path.size()-1 ? file_path.substr( pos+1 ) : "";
pos = tmp_str.rfind( _extension_ );
- if( !with_extension && pos >= 0 )
- tmp_str = pos < (int)tmp_str.size()-1 ? tmp_str.substr( 0, pos ) : "";
+ if( !with_extension && pos >= 0 ) // TODO: always true
+ 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 )
- return pos < (int)file_path.size()-1 ? file_path.substr(0, pos ) : "";
+ if ( pos >= 0 ) // TODO: always true
+ 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 )
+ if( pos < 0 ) // TODO: always true
return tmp_str.append( _extension_ );
return tmp_str;
}
void CallCancelThread() ;
#ifndef WIN32
-void SigIntHandler(int what ,
+void SigIntHandler(int /*what*/ ,
siginfo_t * siginfo ,
- void * toto )
+ void * /*toto*/ )
{
//PAL9042 JR : during the execution of a Signal Handler (and of methods called through Signal Handlers)
// use of streams (and so on) should never be used because :
#else
Engines::Container_ptr
-SALOME_ContainerManager::StartPaCOPPContainer(const Engines::ContainerParameters& params,
- std::string resource_selected)
+SALOME_ContainerManager::StartPaCOPPContainer(const Engines::ContainerParameters& /*params*/,
+ std::string /*resource_selected*/)
{
- SALOME_UNUSED(params);
Engines::Container_ptr ret = Engines::Container::_nil();
INFOS("[StarPaCOPPContainer] is disabled !");
INFOS("[StarPaCOPPContainer] recompile SALOME Kernel to enable PaCO++ parallel extension");
}
std::string
-SALOME_ContainerManager::BuildCommandToLaunchPaCOProxyContainer(const Engines::ContainerParameters& params,
- std::string machine_file_name,
- std::string & proxy_hostname)
+SALOME_ContainerManager::BuildCommandToLaunchPaCOProxyContainer(const Engines::ContainerParameters& /*params*/,
+ std::string /*machine_file_name*/,
+ std::string & /*proxy_hostname*/)
{
- SALOME_UNUSED(params);
- SALOME_UNUSED(proxy_hostname);
return "";
}
std::string
-SALOME_ContainerManager::BuildCommandToLaunchPaCONodeContainer(const Engines::ContainerParameters& params,
- const std::string & machine_file_name,
- SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
- const std::string & proxy_hostname)
+SALOME_ContainerManager::BuildCommandToLaunchPaCONodeContainer(const Engines::ContainerParameters& /*params*/,
+ const std::string & /*machine_file_name*/,
+ SALOME_ContainerManager::actual_launch_machine_t & /*vect_machine*/,
+ const std::string & /*proxy_hostname*/)
{
- SALOME_UNUSED(params);
- SALOME_UNUSED(machine_file_name);
- SALOME_UNUSED(vect_machine);
- SALOME_UNUSED(proxy_hostname);
return "";
}
void
-SALOME_ContainerManager::LogConfiguration(const std::string & log_type,
- const std::string & exe_type,
- const std::string & container_name,
- const std::string & hostname,
- std::string & begin,
- std::string & end)
+SALOME_ContainerManager::LogConfiguration(const std::string & /*log_type*/,
+ const std::string & /*exe_type*/,
+ const std::string & /*container_name*/,
+ const std::string & /*hostname*/,
+ std::string & /*begin*/,
+ std::string & /*end*/)
{
- SALOME_UNUSED(log_type);
- SALOME_UNUSED(exe_type);
- SALOME_UNUSED(container_name);
- SALOME_UNUSED(hostname);
- SALOME_UNUSED(begin);
- SALOME_UNUSED(end);
}
CORBA::Object_ptr
-SALOME_ContainerManager::LaunchPaCOProxyContainer(const std::string& command,
- const Engines::ContainerParameters& params,
- const std::string& hostname)
+SALOME_ContainerManager::LaunchPaCOProxyContainer(const std::string& /*command*/,
+ const Engines::ContainerParameters& /*params*/,
+ const std::string& /*hostname*/)
{
- SALOME_UNUSED(command);
- SALOME_UNUSED(params);
- SALOME_UNUSED(hostname);
CORBA::Object_ptr ret = CORBA::Object::_nil();
return ret;
}
bool
-SALOME_ContainerManager::LaunchPaCONodeContainer(const std::string& command,
- const Engines::ContainerParameters& params,
- const std::string& name,
- SALOME_ContainerManager::actual_launch_machine_t & vect_machine)
-{
- SALOME_UNUSED(command);
- SALOME_UNUSED(params);
- SALOME_UNUSED(name);
- SALOME_UNUSED(vect_machine);
- return false;
+SALOME_ContainerManager::LaunchPaCONodeContainer(const std::string& /*command*/,
+ const Engines::ContainerParameters& /*params*/,
+ const std::string& /*name*/,
+ SALOME_ContainerManager::actual_launch_machine_t & /*vect_machine*/)
+{
+ return false;
}
#endif
std::cerr << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
std::cerr << "Test of getFilesInfos()" << std::endl;
all_infos = file.getFilesInfos();
- for (int i = 0; i < all_infos->length(); i++)
+ for (int i = 0; i < (int)all_infos->length(); i++)
{
print_infos(&((*all_infos)[i]));
}
sort(sorted.begin(), sorted.end());
size_t len = sorted.size();
- for(int i = 0; i<len; i++)
+ for(size_t i = 0; i<len; i++)
attributes.push_back(_node->_attributes[sorted[i]]);
return attributes;
//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) {}
#endif /* DSC_EXCEPTION_HXX */
const char *interfaceName,
bool notif = false);
virtual ~PySupervCompo();
- CORBA::Boolean init_service(const char * service_name){return true;};
- CORBA::Boolean init_service_with_multiple(const char* service_name,
- const Engines::Superv_Component::seq_multiple_param & params)
+ CORBA::Boolean init_service(const char * /*service_name*/){return true;};
+ CORBA::Boolean init_service_with_multiple(const char* /*service_name*/,
+ const Engines::Superv_Component::seq_multiple_param & /*params*/)
{
return true;
}
il sera mappé sur le type int (si il est 32bits). Le type CORBA:LongLong est mappé sur le type long
s'il est 64 bits sinon celà peut être un long long (s'il existe).
*/
-CALCIUM_C2CPP_INTERFACE_HXX_(intc,int,int,);
-CALCIUM_C2CPP_INTERFACE_HXX_(long,long,long,);
+CALCIUM_C2CPP_INTERFACE_HXX_(intc,int,int,)
+CALCIUM_C2CPP_INTERFACE_HXX_(long,long,long,)
-CALCIUM_C2CPP_INTERFACE_HXX_(integer,integer,cal_int,);
-CALCIUM_C2CPP_INTERFACE_HXX_(int2integer,integer,int,);
-CALCIUM_C2CPP_INTERFACE_HXX_(long2integer,integer, long,);
+CALCIUM_C2CPP_INTERFACE_HXX_(integer,integer,cal_int,)
+CALCIUM_C2CPP_INTERFACE_HXX_(int2integer,integer,int,)
+CALCIUM_C2CPP_INTERFACE_HXX_(long2integer,integer, long,)
-CALCIUM_C2CPP_INTERFACE_HXX_(float,float,float, );
-CALCIUM_C2CPP_INTERFACE_HXX_(double,double,double,);
+CALCIUM_C2CPP_INTERFACE_HXX_(float,float,float, )
+CALCIUM_C2CPP_INTERFACE_HXX_(double,double,double,)
-CALCIUM_C2CPP_INTERFACE_HXX_(float2double,double,float, );
+CALCIUM_C2CPP_INTERFACE_HXX_(float2double,double,float, )
/* Fonctionne mais essai suivant pour simplification de Calcium.c CALCIUM_C2CPP_INTERFACE_(bool,bool,);*/
-CALCIUM_C2CPP_INTERFACE_HXX_(bool,bool,int,);
-CALCIUM_C2CPP_INTERFACE_HXX_(cplx,cplx,float,);
-CALCIUM_C2CPP_INTERFACE_HXX_(str,str,char*,);
+CALCIUM_C2CPP_INTERFACE_HXX_(bool,bool,int,)
+CALCIUM_C2CPP_INTERFACE_HXX_(cplx,cplx,float,)
+CALCIUM_C2CPP_INTERFACE_HXX_(str,str,char*,)
/* Déclaration de ecp_fin */
extern "C" CalciumTypes::InfoType ecp_fin_ (void * component, int code);
_interpolationSchem(CalciumTypes::L1_SCHEM),
_extrapolationSchem(CalciumTypes::UNDEFINED_EXTRA_SCHEM),
_alpha(0.0),_deltaT(CalciumTypes::EPSILON),
- _disconnectDirective(CalciumTypes::UNDEFINED_DIRECTIVE){};
+ _disconnectDirective(CalciumTypes::UNDEFINED_DIRECTIVE){}
void CalciumCouplingPolicy::setDependencyType (CalciumTypes::DependencyType dependencyType) {_dependencyType=dependencyType;}
CalciumTypes::DependencyType CalciumCouplingPolicy::getDependencyType () const { return _dependencyType;}
void CalciumCouplingPolicy::setStorageLevel (size_t storageLevel) {
MESSAGE( "CalciumCouplingPolicy::setStorageLevel: " << storageLevel );
- if ( storageLevel < 1 && (storageLevel != CalciumTypes::UNLIMITED_STORAGE_LEVEL) )
+ if ( storageLevel < 1 && (storageLevel != (size_t)CalciumTypes::UNLIMITED_STORAGE_LEVEL) )
throw CalciumException(CalciumTypes::CPRENA,LOC("StorageLevel < 1 is not allowed"));
_storageLevel = storageLevel;
}
_extrapolationSchem=extrapolationSchem;
}
-CalciumTypes::InterpolationSchem CalciumCouplingPolicy::getInterpolationSchem () const { return _interpolationSchem; };
-CalciumTypes::ExtrapolationSchem CalciumCouplingPolicy::getExtrapolationSchem () const { return _extrapolationSchem; };
+CalciumTypes::InterpolationSchem CalciumCouplingPolicy::getInterpolationSchem () const { return _interpolationSchem; }
+CalciumTypes::ExtrapolationSchem CalciumCouplingPolicy::getExtrapolationSchem () const { return _extrapolationSchem; }
CalciumCouplingPolicy::TimeType
template <typename DataManipulator, class EnableIf >
struct CalciumCouplingPolicy::BoundedDataIdProcessor{
- BoundedDataIdProcessor(const CouplingPolicy & couplingPolicy) {};
+ BoundedDataIdProcessor(const CouplingPolicy & /*couplingPolicy*/) {};
template < typename Iterator, typename DataId >
- void inline apply(typename iterator_t<Iterator>::value_type & data,
- const DataId & dataId,
- const Iterator & it1) const {
+ void inline apply(typename iterator_t<Iterator>::value_type & /*data*/,
+ const DataId & /*dataId*/,
+ const Iterator & /*it1*/) const {
typedef typename iterator_t<Iterator>::value_type value_type;
#ifdef MYDEBUG
std::cout << "-------- Calcium Generic BoundedDataIdProcessor.apply() called " << std::endl;
std::cout << "-------- CalciumCouplingPolicy::eraseDataId, storedDatasSize : " << storedDatas.size() << std::endl;
#endif
- if ( _couplingPolicy._storageLevel == CalciumTypes::UNLIMITED_STORAGE_LEVEL ) return;
+ if ( _couplingPolicy._storageLevel == (size_t)CalciumTypes::UNLIMITED_STORAGE_LEVEL ) return;
size_t storedDatasSize = storedDatas.size();
long s = storedDatasSize - _couplingPolicy._storageLevel;
storedDatas.erase(storedDatas.begin());
}
// Si l'itérateur pointait sur une valeur que l'on vient de supprimer
- if (dist < s ) {
+ if (dist < (size_t)s ) {
throw(CalciumException(CalciumTypes::CPNTNULL,LOC(OSS()<< "StorageLevel management "
<< _couplingPolicy._storageLevel <<
" has just removed the data to send")));
namespace CalciumInterface
{
-};
+}
#endif
return;
- };
+ }
template <typename T1> static void
ecp_ecriture ( Superv_Component_i & component,
T1 const & data )
{
ecp_ecriture<T1,T1> (component,dependencyType,t,i,nomVar,bufferLength,data);
- };
+ }
static inline void
ecp_fini(Superv_Component_i & component,const std::string & nomVar,long const & i)
msg << "i<=" << i ;
Engines_DSC_interface::writeEvent("CP_FINI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
- };
+ }
static inline void
ecp_fint(Superv_Component_i & component,const std::string & nomVar,double const & t)
msg << "t<=" << t ;
Engines_DSC_interface::writeEvent("CP_FINT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
- };
+ }
static inline void
ecp_effi(Superv_Component_i & component,const std::string & nomVar,long const & i)
msg << "i>=" << i ;
Engines_DSC_interface::writeEvent("CP_EFFI",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
- };
+ }
static inline void
ecp_efft(Superv_Component_i & component,const std::string & nomVar,double const & t)
msg << "t>=" << t ;
Engines_DSC_interface::writeEvent("CP_EFFT",containerName,componentName,nomVar.c_str(),"",msg.str().c_str());
- };
+ }
-};
+}
#endif
virtual CORBA::Any* get_property(const char* name) \
; \
\
- virtual void provides_port_changed(int connection_nbr, \
+ virtual void provides_port_changed(int /*connection_nbr*/, \
const Engines::DSC::Message message) { \
if ( message == Engines::DSC::AddingConnection) \
{ \
#define CALCIUM_GENERIC_PROVIDES_PORT_CXX(specificPortName) \
\
- specificPortName::~specificPortName(void) {}; \
+ specificPortName::~specificPortName(void) {} \
\
void specificPortName::set_property(const char * name, const CORBA::Any& value) \
{ \
throw Ports::NotDefined(); \
} \
return value; \
- };
+ }
#endif
if (!this->_my_ports)
throw DSC_Exception(LOC("There is no connected provides port to communicate with."));
- for(int i = 0; i < this->_my_ports->length(); i++) {
+ for(int i = 0; i < (int)this->_my_ports->length(); i++) {
CorbaPortTypePtr port = CorbaPortType::_narrow((*this->_my_ports)[i]);
try {
#ifdef MYDEBUG
#include "calcium_logical_port_uses.hxx"
#include "calcium_complex_port_uses.hxx"
-calcium_real_port_uses::~calcium_real_port_uses(void) {};
-calcium_double_port_uses::~calcium_double_port_uses(void) {};
-calcium_integer_port_uses::~calcium_integer_port_uses(void) {};
-calcium_long_port_uses::~calcium_long_port_uses(void) {};
-calcium_intc_port_uses::~calcium_intc_port_uses(void) {};
-calcium_logical_port_uses::~calcium_logical_port_uses(void) {};
-calcium_complex_port_uses::~calcium_complex_port_uses(void) {};
-calcium_string_port_uses::~calcium_string_port_uses(void) {};
+calcium_real_port_uses::~calcium_real_port_uses(void) {}
+calcium_double_port_uses::~calcium_double_port_uses(void) {}
+calcium_integer_port_uses::~calcium_integer_port_uses(void) {}
+calcium_long_port_uses::~calcium_long_port_uses(void) {}
+calcium_intc_port_uses::~calcium_intc_port_uses(void) {}
+calcium_logical_port_uses::~calcium_logical_port_uses(void) {}
+calcium_complex_port_uses::~calcium_complex_port_uses(void) {}
+calcium_string_port_uses::~calcium_string_port_uses(void) {}
virtual InterpolationSchem getInterpolationSchem () const =0;
virtual ExtrapolationSchem getExtrapolationSchem () const =0;
- virtual void calcium_erase (float t,long i, bool before) {};
+ virtual void calcium_erase (float /*t*/,long /*i*/, bool /*before*/) {};
};
#endif
public :
calcium_uses_port();
virtual ~calcium_uses_port();
- virtual void disconnect (bool provideLastGivenValue) {};
+ virtual void disconnect (bool /*provideLastGivenValue*/) {};
};
#endif
// }
// Operation de destruction d'une donnee: rien a faire car pas de memoire a liberer
- static inline void delete_data(Type data) {}
+ static inline void delete_data(Type /*data*/) {}
// Renvoie la taille de la donnée
static inline size_t size(Type data) {
InnerType *dataPtr = getPointer(data,false);
- for (int i = 0; i< isize; ++i)
+ for (size_t i = 0; i< isize; ++i)
idata[i]=dataPtr[i];
// Le mode de recopie suivant ne permet pas la conversion de type (ex int -> CORBA::Long)
// Si idata[i] n'a pas été alloué suffisament grand,
// il y a corruption de la mémoire
- for (int i = 0; i< isize; ++i)
+ for (size_t i = 0; i< isize; ++i)
strcpy(idata[i],dataPtr[i]);
}
template <typename T, typename U> std::ostream & operator <<(std::ostream & os, const std::pair<T,U> & p)
{ os << "(" << p.first << "," << p.second << ")";
return os;
-};
+}
#endif
// Du coup interaction potentielle entre le 0 copy et gestion des niveaux
return dataToTransmit;
-};
+}
#endif
#include "DSC_Exception.hxx"
-// #define GENERATE_USES_PORT(dataManip,portType,portName) \
-// const char * _repository_##portType##_name_ = "IDL:Ports/##portType##:1.0"; \
-// GenericUsesPort< dataManip, portType, _repository_##portType##_name_ > portName;
+/* #define GENERATE_USES_PORT(dataManip,portType,portName) \
+ const char * _repository_##portType##_name_ = "IDL:Ports/##portType##:1.0"; \
+ GenericUsesPort< dataManip, portType, _repository_##portType##_name_ > portName;
-//ex : GENERATE_USES_PORT(Ports::Data_Short_Port,data_short_port);
+ex : GENERATE_USES_PORT(Ports::Data_Short_Port,data_short_port);*/
template <typename DataManipulator, typename CorbaPortType, char * repositoryName,
typename UsesPort=uses_port >
void
GenericUsesPort< DataManipulator, CorbaPortType, repositoryName, UsesPort
>::uses_port_changed(Engines::DSC::uses_port * new_uses_port,
- const Engines::DSC::Message message)
+ const Engines::DSC::Message /*message*/)
{
if (_my_ports) delete _my_ports;
//
void fake_method(void) {
// int fake_int;
-};
+}
//
#include "Superv_Component_i.hxx"
-DSC_EXCEPTION_CXX(Superv_Component_i,BadFabType);
-DSC_EXCEPTION_CXX(Superv_Component_i,BadType);
-DSC_EXCEPTION_CXX(Superv_Component_i,BadCast);
-DSC_EXCEPTION_CXX(Superv_Component_i,UnexpectedState);
-DSC_EXCEPTION_CXX(Superv_Component_i,PortAlreadyDefined);
-DSC_EXCEPTION_CXX(Superv_Component_i,PortNotDefined);
-DSC_EXCEPTION_CXX(Superv_Component_i,PortNotConnected);
-DSC_EXCEPTION_CXX(Superv_Component_i,NilPort);
-DSC_EXCEPTION_CXX(Superv_Component_i,BadProperty);
+DSC_EXCEPTION_CXX(Superv_Component_i,BadFabType)
+DSC_EXCEPTION_CXX(Superv_Component_i,BadType)
+DSC_EXCEPTION_CXX(Superv_Component_i,BadCast)
+DSC_EXCEPTION_CXX(Superv_Component_i,UnexpectedState)
+DSC_EXCEPTION_CXX(Superv_Component_i,PortAlreadyDefined)
+DSC_EXCEPTION_CXX(Superv_Component_i,PortNotDefined)
+DSC_EXCEPTION_CXX(Superv_Component_i,PortNotConnected)
+DSC_EXCEPTION_CXX(Superv_Component_i,NilPort)
+DSC_EXCEPTION_CXX(Superv_Component_i,BadProperty)
std::map<std::string, port_factory*> Superv_Component_i::_factory_map;
long Superv_Component_i::dscTimeOut=0;
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);
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>
// Exceptions declarations.
// There are defined on the Superv_Component_i.cxx to avoid problems
// from dlopen.
- DSC_EXCEPTION(BadFabType);
- DSC_EXCEPTION(BadType);
- DSC_EXCEPTION(BadCast);
- DSC_EXCEPTION(UnexpectedState);
- DSC_EXCEPTION(PortAlreadyDefined);
- DSC_EXCEPTION(PortNotDefined);
- DSC_EXCEPTION(PortNotConnected);
- DSC_EXCEPTION(NilPort);
- DSC_EXCEPTION(BadProperty);
+ DSC_EXCEPTION(BadFabType)
+ DSC_EXCEPTION(BadType)
+ DSC_EXCEPTION(BadCast)
+ DSC_EXCEPTION(UnexpectedState)
+ DSC_EXCEPTION(PortAlreadyDefined)
+ DSC_EXCEPTION(PortNotDefined)
+ DSC_EXCEPTION(PortNotConnected)
+ DSC_EXCEPTION(NilPort)
+ DSC_EXCEPTION(BadProperty)
/*!
* \warning currently disabled.
* \warning currently disabled.
*/
virtual provides_port * create_provides_data_and_control_port(const char* port_type)
- {return NULL;}
+ {SALOME_UNUSED(port_type);return NULL;}
/*!
* \warning currently disabled.
* \warning currently disabled.
*/
virtual uses_port * create_uses_data_and_control_port(const char* port_type)
- {return NULL;}
+ {SALOME_UNUSED(port_type);return NULL;}
/*!
* This method permits to create a provides port provided by the platform.
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;
}
<< port_type));
return retPort;
-};
+}
template <typename SpecificPortType > SpecificPortType *
}
return retPort;
-};
+}
#endif
* \param connection_nbr current connection number.
* \param message message associated with this connection.
*/
- virtual void provides_port_changed(int connection_nbr,
- const Engines::DSC::Message message) {}
+ virtual void provides_port_changed(int /*connection_nbr*/,
+ const Engines::DSC::Message /*message*/) {}
};
UnRegister();
}
-}; // end of namespace SALOME
+} // end of namespace SALOME
// TODO: return <int> or <size_t>?
return static_cast<int>(length);
-};
+}
_father->AddSon(this);
_mid = -1;
_attribute = NULL;
-};
+}
void HDFgroup::CreateOnDisk()
{
//===========================================================================
- SALOMEDS_DriverDefaultImpl::SALOMEDS_DriverDefaultImpl(CORBA::ORB_ptr orb,
- PortableServer::POA_ptr poa,
- PortableServer::ObjectId * contId,
- const char *instanceName,
- const char *interfaceName)
+ SALOMEDS_DriverDefaultImpl::SALOMEDS_DriverDefaultImpl(CORBA::ORB_ptr /*orb*/,
+ PortableServer::POA_ptr /*poa*/,
+ PortableServer::ObjectId * /*contId*/,
+ const char * /*instanceName*/,
+ const char * /*interfaceName*/)
// :Engines_Component_i(orb, poa, contId, instanceName, interfaceName)
{
MESSAGE("SALOMEDS_DriverDefaultImpl::SALOMEDS_DriverDefaultImpl : ");
- };
+ }
//===========================================================================
SALOMEDS_DriverDefaultImpl::~SALOMEDS_DriverDefaultImpl()
{
MESSAGE("SALOMEDS_DriverDefaultImpl::~SALOMEDS_DriverDefaultImpl");
- };
+ }
//===========================================================================
- CORBA::Boolean SALOMEDS_DriverDefaultImpl::Load(SALOMEDS::SComponent_ptr theComponent,
- const SALOMEDS::TMPFile & theStream,
- const char* theURL,
- bool isMultiFile)
+ CORBA::Boolean SALOMEDS_DriverDefaultImpl::Load(SALOMEDS::SComponent_ptr /*theComponent*/,
+ const SALOMEDS::TMPFile & /*theStream*/,
+ const char* /*theURL*/,
+ bool /*isMultiFile*/)
{
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
return false;
- };
+ }
//===========================================================================
- CORBA::Boolean SALOMEDS_DriverDefaultImpl::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
- const SALOMEDS::TMPFile & theStream,
- const char* theURL,
- bool isMultiFile)
+ CORBA::Boolean SALOMEDS_DriverDefaultImpl::LoadASCII(SALOMEDS::SComponent_ptr /*theComponent*/,
+ const SALOMEDS::TMPFile & /*theStream*/,
+ const char* /*theURL*/,
+ bool /*isMultiFile*/)
{
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
return false;
- };
+ }
//===========================================================================
- char* SALOMEDS_DriverDefaultImpl::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
- const char* aLocalPersistentID,
- CORBA::Boolean isMultiFile,
- CORBA::Boolean isASCII)
+ char* SALOMEDS_DriverDefaultImpl::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr /*theSObject*/,
+ const char* /*aLocalPersistentID*/,
+ CORBA::Boolean /*isMultiFile*/,
+ CORBA::Boolean /*isASCII*/)
{
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
CORBA::String_var aString("");
return aString._retn();
- };
+ }
//===========================================================================
- SALOMEDS::TMPFile* SALOMEDS_DriverDefaultImpl::Save(SALOMEDS::SComponent_ptr theComponent,
- const char* theURL,
- bool isMultiFile)
+ SALOMEDS::TMPFile* SALOMEDS_DriverDefaultImpl::Save(SALOMEDS::SComponent_ptr /*theComponent*/,
+ const char* /*theURL*/,
+ bool /*isMultiFile*/)
{
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(0);
return aStreamFile._retn();
- };
+ }
//===========================================================================
- SALOMEDS::TMPFile* SALOMEDS_DriverDefaultImpl::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
- const char* theURL,
- bool isMultiFile)
+ SALOMEDS::TMPFile* SALOMEDS_DriverDefaultImpl::SaveASCII(SALOMEDS::SComponent_ptr /*theComponent*/,
+ const char* /*theURL*/,
+ bool /*isMultiFile*/)
{
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(0);
return aStreamFile._retn();
- };
+ }
//===========================================================================
- char* SALOMEDS_DriverDefaultImpl::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
- const char* IORString,
- CORBA::Boolean isMultiFile,
- CORBA::Boolean isASCII)
+ char* SALOMEDS_DriverDefaultImpl::IORToLocalPersistentID(SALOMEDS::SObject_ptr /*theSObject*/,
+ const char* /*IORString*/,
+ CORBA::Boolean /*isMultiFile*/,
+ CORBA::Boolean /*isASCII*/)
{
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
CORBA::String_var aString("");
return aString._retn();
- };
+ }
//===========================================================================
- void SALOMEDS_DriverDefaultImpl::Close(SALOMEDS::SComponent_ptr theComponent)
+ void SALOMEDS_DriverDefaultImpl::Close(SALOMEDS::SComponent_ptr /*theComponent*/)
{
MESSAGE("------------------------");
MESSAGE("SALOMEDS_DriverDefaultImpl::Close");
MESSAGE("------------------------");
- };
+ }
//===========================================================================
char* SALOMEDS_DriverDefaultImpl::ComponentDataType()
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
return CORBA::string_dup("J aurais du nommer mon type prefere");
- };
+ }
//===========================================================================
- bool SALOMEDS_DriverDefaultImpl::CanPublishInStudy(CORBA::Object_ptr theIOR)
+ bool SALOMEDS_DriverDefaultImpl::CanPublishInStudy(CORBA::Object_ptr /*theIOR*/)
{
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
return false;
- };
+ }
//===========================================================================
- SALOMEDS::SObject_ptr SALOMEDS_DriverDefaultImpl::PublishInStudy(SALOMEDS::SObject_ptr theSObject,
- CORBA::Object_ptr theObject,
- const char* theName)
+ SALOMEDS::SObject_ptr SALOMEDS_DriverDefaultImpl::PublishInStudy(SALOMEDS::SObject_ptr /*theSObject*/,
+ CORBA::Object_ptr /*theObject*/,
+ const char* /* theName*/)
{
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
SALOMEDS::SObject_var aResultSO;
return aResultSO._retn();
- };
+ }
//===========================================================================
- CORBA::Boolean SALOMEDS_DriverDefaultImpl::CanCopy(SALOMEDS::SObject_ptr theObject)
+ CORBA::Boolean SALOMEDS_DriverDefaultImpl::CanCopy(SALOMEDS::SObject_ptr /*theObject*/)
{
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
//return false;
return true;
- };
+ }
//===========================================================================
- SALOMEDS::TMPFile* SALOMEDS_DriverDefaultImpl::CopyFrom(SALOMEDS::SObject_ptr theObject,
- CORBA::Long& theObjectID)
+ SALOMEDS::TMPFile* SALOMEDS_DriverDefaultImpl::CopyFrom(SALOMEDS::SObject_ptr /*theObject*/,
+ CORBA::Long& /*theObjectID*/)
{
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
MESSAGE("--------------------------------------");
SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(0);
return aStreamFile._retn();
-};
+}
//===========================================================================
- SALOMEDS::SObject_ptr SALOMEDS_DriverDefaultImpl::PasteInto( const SALOMEDS::TMPFile & theStream,
- CORBA::Long theObjectID,
- SALOMEDS::SObject_ptr theSObject)
+ SALOMEDS::SObject_ptr SALOMEDS_DriverDefaultImpl::PasteInto( const SALOMEDS::TMPFile & /*theStream*/,
+ CORBA::Long /*theObjectID*/,
+ SALOMEDS::SObject_ptr /*theSObject*/)
{
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
SALOMEDS::SObject_var aResultSO;
return aResultSO._retn();
- };
+ }
//===========================================================================
- CORBA::Boolean SALOMEDS_DriverDefaultImpl::CanPaste ( const char *theComponentName,
- CORBA::Long theObjectID)
+ CORBA::Boolean SALOMEDS_DriverDefaultImpl::CanPaste ( const char * /*theComponentName*/,
+ CORBA::Long /*theObjectID*/)
{
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
MESSAGE("-----------------------------------------");
return false;
- };
+ }
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
std::vector<long> pids(pyh->evalVL(oss.str()));
std::size_t sz(pids.size());
ret->length(sz);
- for(auto i=0;i<sz;i++)
+ for(auto i=0;i<sz;i++) //TODO: mismatch signed/unsugned
(*ret)[i] = pids[i];
#endif
return ret;
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
- for(auto i = 0; i<sz ; i++)
+ for(auto i = 0; i<(int)sz ; i++) //TODO: mismatch signed/unsigned
{
(*ret)[i]=CORBA::string_dup(loes[i].c_str());
}
"RefDirectory: " << RefDirectory << std::endl <<
"NbOfProcesses: " << NbOfProcesses << std::endl <<
"InputFile: ";
- for(int i=0; i <InputFile.size();i++)
+ for(int i=0; i <(int)InputFile.size();i++) //TODO: mismatch signed/unsigned
oss << InputFile[i] << " ";
oss << std::endl << "OutputFile: ";
- for(int i=0; i <OutputFile.size();i++)
+ for(int i=0; i <(int)OutputFile.size();i++) //TODO: mismatch signed/unsigned
oss << OutputFile[i] << " ";
oss << std::endl <<
"Command: " << Command << std::endl <<
#include "SALOME_ModuleCatalog_Acomponent_impl.hxx"
#include "Utils_ExceptHandlers.hxx"
-UNEXPECT_CATCH(MC_NotFound, SALOME_ModuleCatalog::NotFound);
+UNEXPECT_CATCH(MC_NotFound, SALOME_ModuleCatalog::NotFound)
#include "utilities.h"
void SALOME_ModuleCatalogImpl::shutdown()
{
if (!CORBA::is_nil(_orb)) _orb->shutdown(0);
-};
+}
// be recorded
size_t sizePath = splitPath.size();
- if (sizePath > dimension_resultat){
- ASSERT(sizePath == dimension_resultat+1);
+ if (sizePath > (size_t)dimension_resultat){
+ ASSERT(sizePath == (size_t)dimension_resultat+1);
context_name.length(1);
try{
// be destroyed
size_t sizePath = splitPath.size();
- if (sizePath > dimension_resultat)
+ if (sizePath > (size_t)dimension_resultat)
{
- ASSERT(sizePath == dimension_resultat+1);
+ ASSERT(sizePath == (size_t)dimension_resultat+1);
context_name.length(1);
try
dim = splitPath.size(); // directories and final object
context_name.length(static_cast<unsigned long>(dim));
- for (int i=0; i<dim; i++)
+ for (int i=0; i<(int)dim; i++)
{
// SCRUTE(splitPath[i]);
context_name[i].id = CORBA::string_dup(splitPath[i].c_str());
- if (!endWithDelim && (i == dim-1)) // here, the last string is an object
+ if (!endWithDelim && (i == (int)dim-1)) // here, the last string is an object
{
context_name[i].kind = CORBA::string_dup("object");
// MESSAGE("--- " <<splitPath[i] <<".object");
// indirect recursion.
void lock();
void unlock();
-};
+}
#endif
return "0";
char c[3], *buffer = new char[length*3+1];
buffer[length*3] = (char)0;
- for(int i = 0, pos = 0; i<length; i++, pos+=3) {
+ for(int i = 0, pos = 0; i<(int)length; i++, pos+=3) { //TODO: mismatch signed/unsigned
int val = (int)S[i];
buffer[pos] = '%';
sprintf(c, "%.2x", val);
return "";
char c[3], *buffer = new char[length/3+1];
buffer[length/3] = (char)0;
- for(int i = 0, pos = 0; i<length; i+=3, pos++) {
+ for(int i = 0, pos = 0; i<(int)length; i+=3, pos++) { //TODO: mismatch signed/unsigned
c[0] = S[i+1];
c[1] = S[i+2];
c[2] = (char)0;
CheckLocked();
Backup();
- if(Index <= 0 || Index > myValue.size()) throw DFexception("Out of range");
+ if(Index <= 0 || Index > (int)myValue.size()) throw DFexception("Out of range"); // TODO: mismatch signed/unsigned
myValue[Index-1] = Value;
CheckLocked();
Backup();
- if(Index <= 0 || Index > myValue.size()) throw DFexception("Out of range");
+ if(Index <= 0 || Index > (int)myValue.size()) throw DFexception("Out of range"); // TODO: mismatch signed/unsigned
typedef std::vector<int>::iterator VI;
int i = 1;
}
int SALOMEDSImpl_AttributeSequenceOfInteger::Value(const int Index)
{
- if(Index <= 0 || Index > myValue.size()) throw DFexception("Out of range");
+ if(Index <= 0 || Index > (int)myValue.size()) throw DFexception("Out of range"); // TODO: mismatch signed/unsigned
return myValue[Index-1];
}
CheckLocked();
Backup();
- if(Index <= 0 || Index > myValue.size()) throw DFexception("Out of range");
+ if(Index <= 0 || Index > (int)myValue.size()) throw DFexception("Out of range"); // TODO: mismatch signed/unsigned
myValue[Index-1] = Value;
CheckLocked();
Backup();
- if(Index <= 0 || Index > myValue.size()) throw DFexception("Out of range");
+ if(Index <= 0 || Index > (int)myValue.size()) throw DFexception("Out of range"); // TODO: mismatch signed/unsigned
typedef std::vector<double>::iterator VI;
int i = 1;
double SALOMEDSImpl_AttributeSequenceOfReal::Value(const int Index)
{
- if(Index <= 0 || Index > myValue.size()) throw DFexception("Out of range");
+ if(Index <= 0 || Index > (int)myValue.size()) throw DFexception("Out of range"); // TODO: mismatch signed/unsigned
return myValue[Index-1];
}
aProp->Init();
int i;
- for(i = 0; i < myUserName.size(); i++) {
+ for(i = 0; i < (int)myUserName.size(); i++) { //TODO: mismatch signed/unsigned
aProp->SetModification(myUserName[i],
myMinute[i], myHour[i],
myDay[i], myMonth[i], myYear[i]);
std::vector<int> aMinutes, aHours, aDays, aMonths, aYears;
GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears);
- size_t aLength, anIndex, unitsSize = 0, commentSize = 0;;
+ int aLength, anIndex, unitsSize = 0, commentSize = 0;;
for (aLength = 0, anIndex = aNames.size()-1; anIndex >= 0; anIndex--)
aLength += aNames[anIndex].size() + 1;
// - yyyy: year = 4 bytes
// - name: user's name = arbitrary value, minimal length is 0 bytes
// - 1 : records delimiter = 1 byte
- for (anIndex = 2; anIndex + 13 < value.size() ;) {
+ for (anIndex = 2; anIndex + 13 < (int)value.size() ;) { //TODO: mismatch signed/unsigned
char str[10];
int aMinute, aHour, aDay, aMonth, aYear;
str[0] = aCopy[anIndex++];
anIndex += aNameSize + 1;
//Check end of the modifications section
- if(anIndex < value.size() && aCopy[anIndex] == 30)
+ if(anIndex < (int)value.size() && aCopy[anIndex] == 30) //TODO: mismatch signed/unsigned
break;
}
//Case when study contains units and comment properties
- if( anIndex < value.size() ) {
+ if( anIndex < (int)value.size() ) { //TODO: mismatch signed/unsigned
anIndex++; //skip the delimiter of the sections: char(30)
int unitsSize;
for(unitsSize = 0; aCopy[anIndex+unitsSize] != 1; unitsSize++);
}
//Case when study contains components versions
- if( anIndex < value.size() ) {
- while ( anIndex < value.size() && aCopy[anIndex] != 0 ) {
+ if( anIndex < (int)value.size() ) { //TODO: mismatch signed/unsigned
+ while ( anIndex < (int)value.size() && aCopy[anIndex] != 0 ) { //TODO: mismatch signed/unsigned
int modSize;
for(modSize = 0; aCopy[anIndex+modSize] != '='; modSize++);
int verSize;
myNbColumns = theNbColumns;
- while (myCols.size() < myNbColumns) { // append empty columns titles
+ while ((int)myCols.size() < myNbColumns) { // append empty columns titles // TODO: mismatch signed/unsigned
myCols.push_back(std::string(""));
}
const std::vector<int>& theData)
{
CheckLocked();
- if(theData.size() > myNbColumns) SetNbColumns((int)theData.size()); //!< TODO: conversion from size_t to const int, possible loss of data
+ if((int)theData.size() > myNbColumns) SetNbColumns((int)theData.size()); //!< TODO: conversion from size_t to const int, possible loss of data
Backup();
- while (myRows.size() < theRow) { // append new row titles
+ while ((int)myRows.size() < theRow) { // append new row titles // TODO: mismatch signed/unsigned
myRows.push_back(std::string(""));
}
void SALOMEDSImpl_AttributeTableOfInteger::SetRowUnits(const std::vector<std::string>& theUnits)
{
- if (theUnits.size() != GetNbRows()) throw DFexception("Invalid number of rows");
+ if ((int)theUnits.size() != GetNbRows()) throw DFexception("Invalid number of rows"); // TODO: mismatch signed/unsigned
size_t aLength = theUnits.size(), i;
for(i = 1; i <= aLength; i++) SetRowUnit((int)i, theUnits[i-1]); //!< TODO: conversion from size_t to int
void SALOMEDSImpl_AttributeTableOfInteger::SetRowTitles(const std::vector<std::string>& theTitles)
{
- if (theTitles.size() != GetNbRows()) throw DFexception("Invalid number of rows");
+ if ((int)theTitles.size() != GetNbRows()) throw DFexception("Invalid number of rows"); //TODO: mismatch signed/unsigned
size_t aLength = theTitles.size(), i;
for(i = 1; i <= aLength; i++) SetRowTitle((int)i, theTitles[i-1]); //!< TODO: conversion from size_t to int
//Title
l = myTitle.size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(i=0; i<l; i++) {
aString += myTitle[i];
//Row titles
for(i=0; i<myNbRows; i++) {
l = myRows[i].size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(j=0; j<l; j++) {
aString += myRows[i][j];
//Columns titles
for(i=0; i<myNbColumns; i++) {
l = myCols[i].size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(j=0; j<l; j++) {
aString += myCols[i][j];
//Store the table values
l = myTable.size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(MI p = myTable.begin(); p != myTable.end(); p++) {
sprintf(buffer, "%d\n%d\n", p->first, p->second);
//Title
l = myTitle.size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%zu\n", l);
aString+=buffer;
for(i=0; i<l; i++) {
aString += myTitle[i];
//Row titles
for(i=0; i<myNbRows; i++) {
l = myRows[i].size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(j=0; j<l; j++) {
aString += myRows[i][j];
//Columns titles
for(i=0; i<myNbColumns; i++) {
l = myCols[i].size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(j=0; j<l; j++) {
aString += myCols[i][j];
//Store the table values
l = myTable.size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(MI p = myTable.begin(); p != myTable.end(); p++) {
sprintf(buffer, "%d\n%.64e\n", p->first, p->second);
//Row titles
for(i=0; i<myNbRows; i++) {
l = myRows[i].size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(j=0; j<l; j++) {
aString += myRows[i][j];
//Columns titles
for(i=0; i<myNbColumns; i++) {
l = myCols[i].size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(j=0; j<l; j++) {
aString += myCols[i][j];
//Store the table values
l = myTable.size();
- sprintf(buffer, "%Iu\n", l);
+ sprintf(buffer, "%u\n", l);
aString+=buffer;
for(MI p = myTable.begin(); p!=myTable.end(); p++) {
if (p->second.size()) { // check empty string in the value table
}
result = indices;
- for ( int col = 0; col < indices.size(); col++ ) {
+ for ( int col = 0; col < (int)indices.size(); col++ ) { //TODO: mismatch signed/unsigned
int idx = indices[col];
if ( col+1 == idx ) continue;
SwapCells(theRow, col+1, theRow, idx);
int idx1 = 0;
- for ( int i = col+1; i < indices.size() && idx1 == 0; i++)
+ for ( int i = col+1; i < (int)indices.size() && idx1 == 0; i++) //TODO: mismatch signed/unsigned
if ( indices[i] == col+1 ) idx1 = i;
indices[idx1] = idx;
}
}
result = indices;
- for ( int row = 0; row < indices.size(); row++ ) {
+ for ( int row = 0; row < (int)indices.size(); row++ ) { //TODO: mismatch signed/unsigned
int idx = indices[row];
if ( row+1 == idx ) continue;
SwapCells(row+1, theColumn, idx, theColumn);
int idx1 = 0;
- for ( int i = row+1; i < indices.size() && idx1 == 0; i++)
+ for ( int i = row+1; i < (int)indices.size() && idx1 == 0; i++) //TODO: mismathc signed/unsigned
if ( indices[i] == row+1 ) idx1 = i;
indices[idx1] = idx;
}
}
result = indices;
- for ( int col = 0; col < indices.size(); col++ ) {
+ for ( int col = 0; col < (int)indices.size(); col++ ) { //TODO: mismatch signed/unsigned
int idx = indices[col];
if ( col+1 == idx ) continue;
SwapColumns(col+1, idx);
int idx1 = 0;
- for ( int i = col+1; i < indices.size() && idx1 == 0; i++)
+ for ( int i = col+1; i < (int)indices.size() && idx1 == 0; i++) //TODO: mismatch signed/unsigned
if ( indices[i] == col+1 ) idx1 = i;
indices[idx1] = idx;
}
}
result = indices;
- for ( int row = 0; row < indices.size(); row++ ) {
+ for ( int row = 0; row < (int)indices.size(); row++ ) { //TODO: mismatch signed/unsigned
int idx = indices[row];
if ( row+1 == idx ) continue;
SwapRows(row+1, idx);
int idx1 = 0;
- for ( int i = row+1; i < indices.size() && idx1 == 0; i++)
+ for ( int i = row+1; i < (int)indices.size() && idx1 == 0; i++) //TODO: mismatch signed/unsigned
if ( indices[i] == row+1 ) idx1 = i;
indices[idx1] = idx;
}
class SALOMEDSIMPL_EXPORT SALOMEDSImpl_AbstractCallback
{
public:
- virtual bool addSO_Notification(const SALOMEDSImpl_SObject& theSObject){return false;};
- virtual bool removeSO_Notification(const SALOMEDSImpl_SObject& theSObject){return false;};
- virtual bool modifySO_Notification(const SALOMEDSImpl_SObject& theSObject, int reason ){return false;};
- virtual bool modifyNB_Notification(const char* theVarName){return false;};
- virtual void RegisterGenObj (const std::string& theIOR) {}
- virtual void UnRegisterGenObj(const std::string& theIOR) {}
+ virtual bool addSO_Notification(const SALOMEDSImpl_SObject& /*theSObject*/){return false;}
+ virtual bool removeSO_Notification(const SALOMEDSImpl_SObject& /*theSObject*/){return false;}
+ virtual bool modifySO_Notification(const SALOMEDSImpl_SObject& /*theSObject*/, int /*reason*/ ){return false;}
+ virtual bool modifyNB_Notification(const char* /*theVarName*/){return false;}
+ virtual void RegisterGenObj (const std::string& /*theIOR*/) {}
+ virtual void UnRegisterGenObj(const std::string& /*theIOR*/) {}
};
#endif
* Purpose :
*/
//============================================================================
-bool SALOMEDSImpl_StudyBuilder::Load(const SALOMEDSImpl_SObject& sco)
+bool SALOMEDSImpl_StudyBuilder::Load(const SALOMEDSImpl_SObject& /*sco*/)
{
_errorCode = "Not implemented";
return false;
* Purpose :
*/
//============================================================================
-void SALOMEDSImpl_StudyBuilder::UndoLimit(int n)
+void SALOMEDSImpl_StudyBuilder::UndoLimit(int /*n*/)
{
_errorCode = "";
CheckLocked();
//============================================================================
std::string SALOMEDSImpl_Tool::GetNameFromPath(const std::string& thePath) {
if (thePath.empty()) return "";
- size_t pos = thePath.rfind('/');
+ int pos = (int)thePath.rfind('/'); //TODO: conversion from size_t to int
if(pos >= 0) return thePath.substr(pos+1, thePath.size());
pos = thePath.rfind('\\');
if(pos >= 0) return thePath.substr(pos+1, thePath.size());
std::string path;
if (!thePath.empty()) {
- size_t pos = thePath.rfind('/');
+ int pos = (int)thePath.rfind('/'); //TODO: conversion from size_t to int
if (pos < 0) pos = thePath.rfind('\\');
if (pos < 0) pos = thePath.rfind('|');
{
std::vector<std::string> vs;
if(theValue[0] == separator && theValue.size() == 1) return vs;
- size_t pos = theValue.find(separator);
+ int pos = (int)theValue.find(separator); //TODO: conversion from size_t to int
if(pos < 0) {
vs.push_back(theValue);
return vs;
std::vector<std::string> treatRepetation(const std::string& theValue)
{
std::vector<std::string> aResult;
- size_t pos = theValue.find(";*=");
+ int pos = (int)theValue.find(";*="); //TODO: conversion from size_t to int
if(pos < 0 )
{
aResult.push_back(theValue);
{
std::vector<std::string> aResult;
if(theValue[0] == sep ) aResult.push_back(std::string());
- size_t pos = theValue.find(sep);
+ int pos = (int)theValue.find(sep); //TODO: conversion from size_t to int
if(pos < 0 ) {
if(sep == '|')
{
{
}
-void PickelizedPyObjRdOnlyServer::addKeyValueErrorIfAlreadyExisting(PyObject *key, PyObject *value)
+void PickelizedPyObjRdOnlyServer::addKeyValueErrorIfAlreadyExisting(PyObject * /*key*/, PyObject * /*value*/)
{
throw Exception("PickelizedPyObjRdOnlyServer::addKeyValueErrorIfAlreadyExisting : incompatible with RdOnly !");
}
checkKeyPresence(key,true);
}
-void PickelizedPyObjServer::addKeyValueHard(PyObject *key, PyObject *value)
+void PickelizedPyObjServer::addKeyValueHard(PyObject * /*key*/, PyObject * /*value*/)
{
std::ostringstream oss; oss << "PickelizedPyObjServer::addKeyValueHard : var \"" << getVarNameCpp() << "\" is not permitted to alter its value !";
throw Exception(oss.str());
}
-void PickelizedPyObjServer::removeKeyInVarErrorIfNotAlreadyExisting(PyObject *key)
+void PickelizedPyObjServer::removeKeyInVarErrorIfNotAlreadyExisting(PyObject * /*key*/)
{
std::ostringstream oss; oss << "PickelizedPyObjServer::removeKeyInVarErrorIfNotAlreadyExisting : var \"" << getVarNameCpp() << "\" is not permitted to alter its value !";
throw Exception(oss.str());
{
}
-RefCountServ::RefCountServ(const RefCountServ& other):_cnt(1)
+RefCountServ::RefCountServ(const RefCountServ& /*other*/):_cnt(1)
{
}
#include <sstream>
-void SALOMESDS::Sha1Keeper::checkSame(const std::string& varName,const std::string& compareFuncContent, PyObject *oldObj, PyObject *newObj)
+void SALOMESDS::Sha1Keeper::checkSame(const std::string& /*varName*/,const std::string& compareFuncContent, PyObject *oldObj, PyObject *newObj)
{
if(compareFuncContent!=_cmp_func_content)
{
int genExcept()
{
throw SALOME_Exception("a message");
-};
+}
// ============================================================================
/*!
