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);
std::string file_port_name,
Salome_file_i * file)
{
+ SALOME_UNUSED(file);
// By default this method does nothing
}
Engines_Container_i::load_impl( const char* genericRegisterName,
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)
{
+ SALOME_UNUSED(self);
Py_INCREF(Py_None);
return Py_None;
}
#include <SALOMEconfig.h>
+#include "Basics_Utils.hxx"
#include "SALOME_Container.hxx"
#include <iostream>
// Object information
virtual bool hasObjectInfo() { return false; }
- virtual char* getObjectInfo(const char* entry) { return CORBA::string_dup(""); }
+ virtual char* getObjectInfo(const char* entry) { SALOME_UNUSED(entry); return CORBA::string_dup(""); }
// Version information
virtual char* getVersion();
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 machine_file_name,
std::string & proxy_hostname)
{
+ SALOME_UNUSED(params);
+ SALOME_UNUSED(proxy_hostname);
return "";
}
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
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
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;
}
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;
}
#endif
// $Header:
//
#include "Salome_file_i.hxx"
+#include "Basics_Utils.hxx"
#include "utilities.h"
#include <stdlib.h>
#include "HDFOI.hxx"
void
Salome_file_i::removeFile(const char* file_name)
{
+ SALOME_UNUSED(file_name);
MESSAGE("Salome_file_i::removeFile : NOT YET IMPLEMENTED");
}
#include "DF_definitions.hxx"
#include "DF_Application.hxx"
+#include "Basics_Utils.hxx"
//Constructor
DF_Application::DF_Application()
//pointer to opened document.
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)
{
+ 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)
{
+ SALOME_UNUSED(theData);
//Not implemented
}
//============================================================================
void SaveAttributeInASCIIfile(HDFattribute *hdf_attribute, FILE* fp, int ident)
{
+ SALOME_UNUSED(ident);
hdf_attribute->OpenOnDisk();
hdf_type type = hdf_attribute->GetType();
#include "hdfi.h"
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
+#include "Basics_Utils.hxx"
HDFcontainerObject::HDFcontainerObject(const char *name)
: HDFinternalObject(name)
void HDFcontainerObject::InternalObjectIndentify(int rank, char *object_name)
{
+ SALOME_UNUSED(rank);
object_name = NULL;
}
#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)
{
+ 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)
{
+ 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)
{
+ SALOME_UNUSED(loc_id);
*(char**)operator_data = new char[strlen(attr_name)+1];
strcpy(*(char**)operator_data, attr_name);
return 1;
#include "hdfi.h"
#include <stdlib.h>
-
/*
* - Name : HDFnObjects
* - Description : returns the number of HDF objects in an HDF group
hdf_err Num(hdf_idt id,const char *name, void *data)
{
int *count;
-
+ (void)name;
+ (void)id;
count = (int *) data;
(*count)++;
hdf_err RankInfo(hdf_idt id, const char *name, void *data)
{
+ (void)id;
if ( data )
strcpy( (char*)data, name );
else
#endif
#ifdef WIN32
-#pragma warning(disable:4275) // Disable warning interface non dll
+//#pragma warning(disable:4275) // Disable warning interface non dll
#endif
class LOGGER_EXPORT Logger :
// Module : SALOME
//
#include "SALOME_Trace.hxx"
+#include "Basics_Utils.hxx"
#include <memory.h>
#include <string>
//#include <stdio.h>
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
// Module : SALOME
//
#include "NOTIFICATION.hxx"
+#include "Basics_Utils.hxx"
NOTIFICATION_Consumer::NOTIFICATION_Consumer():
proxy_supplier(0),
}
void NOTIFICATION_Consumer::offer_change(const CosN_EventTypeSeq& added, const CosN_EventTypeSeq& deled) {
+ SALOME_UNUSED(added); SALOME_UNUSED(deled);
}
// Module : SALOME
//
#include "NOTIFICATION.hxx"
+#include "Basics_Utils.hxx"
long NOTIFICATION_Supplier::_stamp = 0;
}
void NOTIFICATION_Supplier::subscription_change(const CosN_EventTypeSeq& added, const CosN_EventTypeSeq& deled) {
+ SALOME_UNUSED(added); SALOME_UNUSED(deled);
}
infos.pid = lesInfos.pid() ;
infos.machine = CORBA::string_dup( lesInfos.host_char() ) ;
infos.adip = CORBA::string_dup( lesInfos.adip() ) ;
- infos.uid = (long)lesInfos.uid() ;
+ infos.uid = /*(long)*/(CORBA::Long)((LONG_PTR)lesInfos.uid()) ; //!< TODO: pointer truncation from const PSID to long
infos.pwname = CORBA::string_dup( lesInfos.pwname() ) ;
- infos.tc_start = lesInfos.start() ;
+ 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 ;
ASSERT(_reg.find(id)!=_reg.end())
_reg[id]->_status=TERMINATED;
- _reg[id]->_ts_end = time(NULL) ;
+ _reg[id]->_ts_end = (long)time(NULL) ; //!< TODO: conversation from time_t to long
_fin[id]=_reg[id];
_reg.erase(id);
ASSERT(strlen(_SessionName)>0) ;
ASSERT(_reg.find(id)!=_reg.end())
- _reg[id]->_ts_hello = time(NULL) ;
+ _reg[id]->_ts_hello = (long)time(NULL) ; //!< TODO: conversation from time_t to long
END_OF("RegistryService::hello") ;
return ;
_adip(duplicate(infos.adip)),\
_uid(infos.uid),\
_pwname(duplicate(infos.pwname)),\
- _ts_start(time(NULL)),\
+ _ts_start((long)time(NULL)),\
_difftime(infos.tc_start - _ts_start),\
_cdir(duplicate(infos.cdir)),\
_ts_hello(_ts_start),\
std::string LoadRateManagerFirst::Find(const std::vector<std::string>& hosts,
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)
{
+ 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
{
//#define _DEVDEBUG_
#include "FileTraceCollector.hxx"
+#include "Basics_Utils.hxx"
// Class attributes initialisation, for class method FileTraceCollector::run
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)
{
+ 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
// Author : Anthony GEAY (EDF R&D)
#include "SALOMESDS_RefCountServ.hxx"
+#include "Basics_Utils.hxx"
using namespace SALOMESDS;
// $Header$
//
#include <SALOMEconfig.h>
+#include "Basics_Utils.hxx"
#include <iostream>
#include <sstream>
void* SALOMETraceCollector::run(void *bid)
{
+ SALOME_UNUSED(bid);
_threadId = new pthread_t;
*_threadId = pthread_self();
sem_post(&_sem); // unlock instance