LauncherServer hostes DataServerManager and default DataScopeServer.
Little correction.
First executable test.
ScopeServer launching.
Debug. Now scope server are correctly launched.
ScopeServer are correctly created and destroyed.
Small correction.
On the road for remote python evaluation of global vars.
Debuging done -> valgrind OK.
string -> sequence<octet> to support the exchance via CORBA or pickled strings + addition of some useful methods.
A good version. TODO : 1 - multi levels management 2 - clean exception handling
Suppress AnyDataServer for the moment.
String -> PyObject + support of invocation of methods recursively.
A full use case is runnable. Remaining : raise management, float, string
Little Bug.
Imp
Exceptions management + clean DataScopes destruction.
on the road of read only and read ext. coming soon \!
End of preparation to move to RdExt instead of RdWr.
First impl of RdExt policy.
Almost ready to be used. Valgrind OK on TestSalomeSDS2.
OK. Only RdOnly and RdExt is now available.
LIST(APPEND _${PROJECT_NAME}_exposed_targets
DF SalomeLoggerServer with_loggerTraceCollector SalomeNS SalomeGenericObj
Registry SalomeCatalog ResourcesManager SalomeResourcesManager
- SalomeNotification SalomeContainer Launcher SalomeLauncher
+ SalomeNotification SalomeContainer SalomeSDS Launcher SalomeLauncher
SalomeLifeCycleCORBA SalomeDSClient TOOLSDS SalomeKernelHelpers
SalomeDSImpl SalomeDS SalomeCommunication SalomeDSCContainer)
# Temporary solution for package src\DSC on windows
SET(KERNEL_SalomeCatalog SalomeCatalog)
SET(KERNEL_SalomeCommunication SalomeCommunication)
SET(KERNEL_SalomeContainer SalomeContainer)
+SET(KERNEL_SalomeSDS SalomeSDS)
SET(KERNEL_SalomeDatastream SalomeDatastream)
SET(KERNEL_SalomeDSCContainer SalomeDSCContainer)
SET(KERNEL_SalomeDSClient SalomeDSClient)
SALOMEDS_Attributes.idl
SALOME_Component.idl
SALOME_ContainerManager.idl
+ SALOME_SDS.idl
SALOME_Registry.idl
Logger.idl
SALOME_GenericObj.idl
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOME_GenericObj.idl"
+#include "SALOME_Exception.idl"
+
+module SALOME
+{
+ typedef sequence<string> StringVec;
+ typedef sequence<octet> ByteVec;
+
+ interface DataScopeServer;
+
+ interface BasicDataServer : GenericObj
+ {
+ DataScopeServer getMyDataScopeServer();
+ string getVarName();
+ string getScopeName();
+ };
+
+ interface PickelizedPyObjServer : BasicDataServer
+ {
+ ByteVec fetchSerializedContent() raises (SALOME::SALOME_Exception);
+ };
+
+ interface PickelizedPyObjRdOnlyServer : PickelizedPyObjServer
+ {
+ };
+
+ interface PickelizedPyObjRdExtServer : PickelizedPyObjServer
+ {
+ PickelizedPyObjRdExtServer invokePythonMethodOn(in string method, in ByteVec args) raises (SALOME::SALOME_Exception);
+ };
+
+ interface PickelizedPyObjRdWrServer : PickelizedPyObjServer
+ {
+ void setSerializedContent(in ByteVec newValue) raises (SALOME::SALOME_Exception);
+ PickelizedPyObjRdWrServer invokePythonMethodOn(in string method, in ByteVec args) raises (SALOME::SALOME_Exception);
+ };
+
+ interface DataServerManager;
+
+ interface DataScopeServer
+ {
+ void ping();
+ string getScopeName();
+ StringVec listVars();
+ BasicDataServer retrieveVar(in string varName) raises (SALOME::SALOME_Exception);
+ void deleteVar(in string varName) raises (SALOME::SALOME_Exception);
+ PickelizedPyObjRdOnlyServer createRdOnlyVar(in string varName, in ByteVec constValue) raises (SALOME::SALOME_Exception);
+ PickelizedPyObjRdExtServer createRdExtVar(in string varName, in ByteVec constValue) raises (SALOME::SALOME_Exception);
+ //PickelizedPyObjRdWrServer createRdWrVar(in string typeName, in string varName) raises (SALOME::SALOME_Exception);
+ void shutdownIfNotHostedByDSM();
+ };
+
+ interface DataServerManager
+ {
+ StringVec listScopes();
+ StringVec listAliveAndKickingScopes() raises (SALOME::SALOME_Exception);
+ DataScopeServer getDefaultScope() raises (SALOME::SALOME_Exception);
+ boolean isAliveAndKicking(in string scopeName) raises (SALOME::SALOME_Exception);
+ DataScopeServer createDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
+ DataScopeServer retriveDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
+ DataScopeServer giveADataScopeCalled(in string scopeName, out boolean isCreated);
+ void removeDataScope(in string scopeName) raises (SALOME::SALOME_Exception);
+ void cleanScopesInNS();
+ void shutdownScopes() raises (SALOME::SALOME_Exception);
+ };
+};
Notification
NOTIFICATION_SWIG
Container
+ SALOMESDS
TestContainer
Launcher
LifeCycleCORBA
//
#include "SALOME_ContainerManager.hxx"
+#include "SALOME_ResourcesManager.hxx"
+#include "SALOME_LoadRateManager.hxx"
#include "SALOME_NamingService.hxx"
#include "SALOME_ResourcesManager_Client.hxx"
#include "SALOME_ModuleCatalog.hh"
#include "PaCOPP.hxx"
#endif
-#define TIME_OUT_TO_LAUNCH_CONT 60
+const int SALOME_ContainerManager::TIME_OUT_TO_LAUNCH_CONT=60;
const char *SALOME_ContainerManager::_ContainerManagerNameInNS =
"/ContainerManager";
logFilename += tmp.str();
logFilename += ".log" ;
command += " > " + logFilename + " 2>&1";
-#ifdef WIN32
- command = "%PYTHONBIN% -c \"import win32pm ; win32pm.spawnpid(r'" + command + "', '')\"";
-#else
- command += " &";
-#endif
+ MakeTheCommandToBeLaunchedASync(command);
// launch container with a system call
status=SystemThreadSafe(command.c_str());
else
{
// Step 4: Wait for the container
- int count = TIME_OUT_TO_LAUNCH_CONT;
- if (GetenvThreadSafe("TIMEOUT_TO_LAUNCH_CONTAINER") != 0)
- {
- std::string new_count_str = GetenvThreadSafe("TIMEOUT_TO_LAUNCH_CONTAINER");
- int new_count;
- std::istringstream ss(new_count_str);
- if (!(ss >> new_count))
- {
- INFOS("[LaunchContainer] TIMEOUT_TO_LAUNCH_CONTAINER should be an int");
- }
- else
- count = new_count;
- }
+ int count(GetTimeOutToLoaunchServer());
INFOS("[GiveContainer] waiting " << count << " second steps container " << containerNameInNS);
while (CORBA::is_nil(ret) && count)
{
-#ifndef WIN32
- sleep( 1 ) ;
-#else
- Sleep(1000);
-#endif
+ SleepInSecond(1);
count--;
MESSAGE("[GiveContainer] step " << count << " Waiting for container on " << resource_selected);
- CORBA::Object_var obj = _NS->Resolve(containerNameInNS.c_str());
+ CORBA::Object_var obj(_NS->Resolve(containerNameInNS.c_str()));
ret=Engines::Container::_narrow(obj);
}
if (CORBA::is_nil(ret))
void SALOME_ContainerManager::AddOmninamesParams(std::string& command) const
{
- CORBA::String_var iorstr = _NS->getIORaddr();
- command += "ORBInitRef NameService=";
- command += iorstr;
+ std::ostringstream oss;
+ AddOmninamesParams(oss);
+ command+=oss.str();
}
//=============================================================================
*/
//=============================================================================
-void SALOME_ContainerManager::AddOmninamesParams(std::ofstream& fileStream) const
+void SALOME_ContainerManager::AddOmninamesParams(std::ostream& fileStream) const
{
- CORBA::String_var iorstr = _NS->getIORaddr();
- fileStream << "ORBInitRef NameService=";
- fileStream << iorstr;
+ AddOmninamesParams(fileStream,_NS);
}
//=============================================================================
*/
//=============================================================================
-void SALOME_ContainerManager::AddOmninamesParams(std::ostringstream& oss) const
+void SALOME_ContainerManager::AddOmninamesParams(std::ostream& fileStream, SALOME_NamingService *ns)
+{
+ CORBA::String_var iorstr(ns->getIORaddr());
+ fileStream << "ORBInitRef NameService=";
+ fileStream << iorstr;
+}
+
+void SALOME_ContainerManager::MakeTheCommandToBeLaunchedASync(std::string& command)
{
- CORBA::String_var iorstr = _NS->getIORaddr();
- oss << "ORBInitRef NameService=";
- oss << iorstr;
+#ifdef WIN32
+ command = "%PYTHONBIN% -c \"import win32pm ; win32pm.spawnpid(r'" + command + "', '')\"";
+#else
+ command += " &";
+#endif
+}
+
+int SALOME_ContainerManager::GetTimeOutToLoaunchServer()
+{
+ int count(TIME_OUT_TO_LAUNCH_CONT);
+ if (GetenvThreadSafe("TIMEOUT_TO_LAUNCH_CONTAINER") != 0)
+ {
+ std::string new_count_str(GetenvThreadSafe("TIMEOUT_TO_LAUNCH_CONTAINER"));
+ int new_count;
+ std::istringstream ss(new_count_str);
+ if (!(ss >> new_count))
+ {
+ INFOS("[LaunchContainer] TIMEOUT_TO_LAUNCH_CONTAINER should be an int");
+ }
+ else
+ count = new_count;
+ }
+ return count;
+}
+
+void SALOME_ContainerManager::SleepInSecond(int ellapseTimeInSecond)
+{
+#ifndef WIN32
+ sleep( ellapseTimeInSecond ) ;
+#else
+ int timeInMS(1000*ellapseTimeInSecond);
+ Sleep(timeInMS);
+#endif
}
//=============================================================================
return container_proxy;
}
- int count = TIME_OUT_TO_LAUNCH_CONT;
+ int count(GetTimeOutToLoaunchServer());
CORBA::Object_var obj = CORBA::Object::_nil();
std::string containerNameInNS = _NS->BuildContainerNameForNS(params.container_name.in(),
hostname.c_str());
std::string container_node_name = name + proc_number;
std::string containerNameInNS = _NS->BuildContainerNameForNS((char*) container_node_name.c_str(), theMachine.c_str());
INFOS("[LaunchPaCONodeContainer] Waiting for Parallel Container node " << containerNameInNS << " on " << theMachine);
- int count = TIME_OUT_TO_LAUNCH_CONT;
+ int count(GetTimeOutToLoaunchServer());
while (CORBA::is_nil(obj) && count) {
- sleep(1) ;
+ SleepInSecond(1);
count-- ;
obj = _NS->Resolve(containerNameInNS.c_str());
}
void AddOmninamesParams(std::string& command) const;
- void AddOmninamesParams(std::ostringstream& oss) const;
-
- void AddOmninamesParams(std::ofstream& fileStream) const;
+ void AddOmninamesParams(std::ostream& fileStream) const;
static std::string BuildTemporaryFileName();
public:
static char *GetenvThreadSafe(const char *name);
static int SystemThreadSafe(const char *command);
-private:
+ static void AddOmninamesParams(std::ostream& fileStream, SALOME_NamingService *ns);
+ static void MakeTheCommandToBeLaunchedASync(std::string& command);
+ static int GetTimeOutToLoaunchServer();
+ static void SleepInSecond(int ellapseTimeInSecond);
+ private:
+ static const int TIME_OUT_TO_LAUNCH_CONT;
static Utils_Mutex _getenvMutex;
static Utils_Mutex _systemMutex;
};
${CMAKE_CURRENT_SOURCE_DIR}/../Notification
${CMAKE_CURRENT_SOURCE_DIR}/../Container
${CMAKE_CURRENT_SOURCE_DIR}/../ResourcesManager
+ ${CMAKE_CURRENT_SOURCE_DIR}/../SALOMESDS
${PROJECT_BINARY_DIR}/idl
)
SET(SALOME_LauncherServer_LIBS
Launcher
SalomeLauncher
+ SalomeSDS
SALOMEBasics
SALOMELocalTrace
${LIBBATCH_LIBRARIES}
#include "BatchTest.hxx"
#include "OpUtil.hxx"
#include "SALOME_ContainerManager.hxx"
+#include "SALOME_NamingService.hxx"
#include "SALOME_ResourcesManager.hxx"
#include "Utils_CorbaException.hxx"
#include "Launcher_Job_YACSFile.hxx"
#include "Launcher_Job_PythonSALOME.hxx"
+#include "utilities.h"
+
#ifdef WIN32
# include <process.h>
#else
//
#include "SALOME_Launcher.hxx"
+#include "SALOMESDS_DataServerManager.hxx"
#include "utilities.h"
#include <sstream>
#include <iostream>
if(!CORBA::is_nil(obj))
root_poa = PortableServer::POA::_narrow(obj);
if(!CORBA::is_nil(root_poa))
- pman = root_poa->the_POAManager();
+ {
+ pman = root_poa->the_POAManager();
+ pman->activate();
+ }
}
catch(CORBA::COMM_FAILURE&){
MESSAGE( "Container: CORBA::COMM_FAILURE: Unable to contact the Naming Service" );
}
- try{
- SALOME_Launcher *lServ=new SALOME_Launcher(orb,root_poa);
- pman->activate();
- lServ->_remove_ref();
- orb->run();
- orb->destroy();
- }catch(CORBA::SystemException&){
+ try
+ {
+ SALOME_Launcher *lServ(new SALOME_Launcher(orb,root_poa));
+ lServ->_remove_ref();
+ //
+ SALOMESDS::DataServerManager *dsm(new SALOMESDS::DataServerManager(argc,argv,orb,root_poa));
+ dsm->_remove_ref();
+ //
+ orb->run();
+ orb->destroy();
+ }
+ catch(CORBA::SystemException&){
MESSAGE("Caught CORBA::SystemException.");
}catch(PortableServer::POA::WrongPolicy&){
MESSAGE("Caught CORBA::WrongPolicyException.");
${CMAKE_CURRENT_SOURCE_DIR}/../Batch
${CMAKE_CURRENT_SOURCE_DIR}/../Notification
${CMAKE_CURRENT_SOURCE_DIR}/../Registry
+ ${CMAKE_CURRENT_SOURCE_DIR}/../SALOMESDS
${PROJECT_BINARY_DIR}/idl
)
SalomeContainer
SalomeResourcesManager
SalomeNS
+ SalomeSDS
OpUtil
SALOMELocalTrace
SALOMEBasics
#include <ServiceUnreachable.hxx>
#include "SALOME_LifeCycleCORBA.hxx"
+#include "SALOME_ResourcesManager.hxx"
+#include "SALOMESDS_DataServerManager.hxx"
+
#include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog)
#include CORBA_CLIENT_HEADER(SALOME_Session)
#include CORBA_CLIENT_HEADER(DSC_Engines)
#include CORBA_CLIENT_HEADER(SALOME_Registry)
#include CORBA_CLIENT_HEADER(SALOMEDS)
+#include CORBA_CLIENT_HEADER(SALOME_SDS)
#include CORBA_CLIENT_HEADER(Logger)
#include CORBA_CLIENT_HEADER(SALOME_Launcher)
#ifndef WIN32
nanosleep(&ts_req,0);
#endif
+ // 4 ) Remote ScopeServer (the DataServer is hosted by SalomeLauncher shutdown right after)
+ try
+ {
+ CORBA::Object_var objDSM(_NS->Resolve(SALOMESDS::DataServerManager::NAME_IN_NS));
+ SALOME::DataServerManager_var dsm(SALOME::DataServerManager::_narrow(objDSM));
+ if ( !CORBA::is_nil(dsm) )
+ dsm->shutdownScopes();
+ }
+ catch(const CORBA::Exception& e)
+ {
+ // ignore and continue
+ }
- // 4) SalomeLauncher
+ // 5) SalomeLauncher
try
{
CORBA::Object_var objSL = _NS->Resolve("/SalomeLauncher");
nanosleep(&ts_req,0);
#endif
- // 5) Registry
+ // 6) Registry
try
{
CORBA::Object_var objR = _NS->Resolve("/Registry");
// ignore and continue
}
- /*
- // 6) Session
- if ( !CORBA::is_nil( session ) ) {
- try
- {
- session->Shutdown();
- }
- catch(const CORBA::Exception& e)
- {
- // ignore and continue
- }
- }
- */
-
// 7) Logger
int argc = 0;
char *xargv = (char*)"";
#include "Utils_ORB_INIT.hxx"
#include "Utils_SINGLETON.hxx"
#include "Basics_Utils.hxx"
+#include "utilities.h"
#include <iostream>
#include <fstream>
#include "SALOME_ResourcesManager.hxx"
#include "SALOME_ContainerManager.hxx"
#include "SALOME_LifeCycleCORBA.hxx"
+#include "SALOME_ResourcesManager.hxx"
#include "NamingService_WaitForServerReadiness.hxx"
#include "OpUtil.hxx"
#include "Utils_ORB_INIT.hxx"
#include <vector>
#include <string>
-#include "utilities.h"
#include "Utils_Mutex.hxx"
#include "ServiceUnreachable.hxx"
#include "Utils_SINGLETON.hxx"
#include "Basics_Utils.hxx"
#include "SALOME_LifeCycleCORBA.hxx"
+#include "utilities.h"
#include <iostream>
#include <fstream>
#include "SALOMEDSImpl_Study.hxx"
#include "Utils_ORB_INIT.hxx"
-#include "Utils_SINGLETON.hxx"
+#include "Utils_SINGLETON.hxx"
+#include "utilities.h"
#include "Basics_Utils.hxx"
--- /dev/null
+# Copyright (C) 2012-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# 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
+#
+# Author : Anthony GEAY (EDF R&D)
+
+INCLUDE_DIRECTORIES(
+ ${OMNIORB_INCLUDE_DIR}
+ ${PTHREAD_INCLUDE_DIR}
+ ${PYTHON_INCLUDE_DIRS}
+ ${PROJECT_BINARY_DIR}/idl
+ ${PROJECT_BINARY_DIR}/salome_adm
+ ${CMAKE_CURRENT_SOURCE_DIR}/../Utils
+ ${CMAKE_CURRENT_SOURCE_DIR}/../NamingService
+ ${CMAKE_CURRENT_SOURCE_DIR}/../Container
+ ${CMAKE_CURRENT_SOURCE_DIR}/../ResourcesManager
+)
+
+ADD_DEFINITIONS(${OMNIORB_DEFINITIONS} ${PYTHON_DEFINITIONS})
+
+SET(COMMON_LIBS SalomeNS SalomeContainer SalomeIDLKernel ${OMNIORB_LIBRARIES} ${PYTHON_LIBRARIES})
+
+SET(SalomeSDS_SOURCES
+ SALOMESDS_Exception.cxx
+ SALOMESDS_RefCountServ.cxx
+ SALOMESDS_BasicDataServer.cxx
+ SALOMESDS_DataScopeServer.cxx
+ SALOMESDS_DataServerManager.cxx
+ SALOMESDS_PickelizedPyObjServer.cxx
+ SALOMESDS_PickelizedPyObjRdOnlyServer.cxx
+ SALOMESDS_PickelizedPyObjRdExtServer.cxx
+ SALOMESDS_PickelizedPyObjRdWrServer.cxx
+ )
+
+ADD_LIBRARY(SalomeSDS ${SalomeSDS_SOURCES})
+TARGET_LINK_LIBRARIES(SalomeSDS ${COMMON_LIBS} ${PTHREAD_LIBRARIES})
+INSTALL(TARGETS SalomeSDS EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+
+ADD_EXECUTABLE(SALOME_DataScopeServer SALOME_DataScopeServer.cxx)
+TARGET_LINK_LIBRARIES(SALOME_DataScopeServer SalomeSDS)
+INSTALL(TARGETS SALOME_DataScopeServer DESTINATION ${SALOME_INSTALL_BINS})
+INSTALL(FILES SalomeSDSClt.py DESTINATION ${SALOME_INSTALL_BINS})
+
+FILE(GLOB COMMON_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${SALOME_INSTALL_HEADERS})
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+#
+# 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
+#
+# Author : Anthony Geay
+
+# dict,list,tuple,int,float,str
+import SALOME
+import cPickle
+
+class List(object):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ assert(isinstance(varPtr,SALOME._objref_StringDataServer))
+ self._var_ptr=varPtr
+ if not isTemporaryVar:
+ self._var_ptr.Register()
+ self._is_temp=isTemporaryVar
+ pass
+
+ def __del__(self):
+ self._var_ptr.UnRegister()
+ pass
+
+ def assign(self,elt):
+ st=cPickle.dumps(elt,cPickle.HIGHEST_PROTOCOL)
+ self._var_ptr.setSerializedContent(st)
+ pass
+
+ def __getitem__(self,*args):
+ ret=Caller(self._var_ptr,"__getitem__")
+ return ret(*args)
+
+ def __setitem__(self,*args):
+ ret=Caller(self._var_ptr,"__setitem__")
+ return ret(*args)
+
+ def append(self,*args):
+ ret=Caller(self._var_ptr,"append")
+ return ret(*args)
+
+ def __str__(self):
+ return self.local_copy().__str__()
+
+ def __repr__(self):
+ return self.local_copy().__repr__()
+
+ def local_copy(self):
+ return cPickle.loads(self._var_ptr.fetchSerializedContent())
+
+ def __reduce__(self):
+ return (list,(self.local_copy(),))
+
+ pass
+
+class Tuple(object):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ assert(isinstance(varPtr,SALOME._objref_StringDataServer))
+ self._var_ptr=varPtr
+ if not isTemporaryVar:
+ self._var_ptr.Register()
+ self._is_temp=isTemporaryVar
+ pass
+
+ def __del__(self):
+ self._var_ptr.UnRegister()
+ pass
+
+ def assign(self,elt):
+ st=cPickle.dumps(elt,cPickle.HIGHEST_PROTOCOL)
+ self._var_ptr.setSerializedContent(st)
+ pass
+
+ def __getitem__(self,*args):
+ ret=Caller(self._var_ptr,"__getitem__")
+ return ret(*args)
+
+ def __setitem__(self,*args):
+ ret=Caller(self._var_ptr,"__setitem__")
+ return ret(*args)
+
+ def __str__(self):
+ return self.local_copy().__str__()
+
+ def __repr__(self):
+ return self.local_copy().__repr__()
+
+ def local_copy(self):
+ return cPickle.loads(self._var_ptr.fetchSerializedContent())
+
+ def __reduce__(self):
+ return (tuple,(self.local_copy(),))
+
+ pass
+
+
+class Int(object):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ assert(isinstance(varPtr,SALOME._objref_StringDataServer))
+ self._var_ptr=varPtr
+ if not isTemporaryVar:
+ self._var_ptr.Register()
+ self._is_temp=isTemporaryVar
+ pass
+
+ def __del__(self):
+ self._var_ptr.UnRegister()
+ pass
+
+ def __iadd__(self,*args):
+ ret=Caller(self._var_ptr,"__add__")
+ return ret(*args)
+
+ def __isub__(self,*args):
+ ret=Caller(self._var_ptr,"__sub__")
+ return ret(*args)
+
+ def assign(self,elt):
+ st=cPickle.dumps(elt,cPickle.HIGHEST_PROTOCOL)
+ self._var_ptr.setSerializedContent(st)
+ pass
+
+ def __str__(self):
+ return self.local_copy().__str__()
+
+ def __repr__(self):
+ return self.local_copy().__repr__()
+
+ def local_copy(self):
+ return cPickle.loads(self._var_ptr.fetchSerializedContent())
+
+ def __reduce__(self):
+ return (int,(self.local_copy(),))
+
+ pass
+
+class Dict(object):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ assert(isinstance(varPtr,SALOME._objref_StringDataServer))
+ self._var_ptr=varPtr
+ if not isTemporaryVar:
+ self._var_ptr.Register()
+ self._is_temp=isTemporaryVar
+ pass
+
+ def __del__(self):
+ self._var_ptr.UnRegister()
+ pass
+
+ def assign(self,elt):
+ st=cPickle.dumps(elt,cPickle.HIGHEST_PROTOCOL)
+ self._var_ptr.setSerializedContent(st)
+ pass
+
+ def __getitem__(self,*args):
+ ret=Caller(self._var_ptr,"__getitem__")
+ return ret(*args)
+
+ def __setitem__(self,*args):
+ ret=Caller(self._var_ptr,"__setitem__")
+ return ret(*args)
+
+ def __len__(self):
+ return len(self.local_copy())
+
+ def __str__(self):
+ return self.local_copy().__str__()
+
+ def __repr__(self):
+ return self.local_copy().__repr__()
+
+ def local_copy(self):
+ return cPickle.loads(self._var_ptr.fetchSerializedContent())
+
+ def __reduce__(self):
+ return (dict,(self.local_copy(),))
+
+ pass
+
+class Caller:
+ def __init__(self,varPtr,meth):
+ assert(isinstance(varPtr,SALOME._objref_StringDataServer))
+ self._var_ptr=varPtr
+ self._meth=meth
+ pass
+
+ def __call__(self,*args):
+ ret=self._var_ptr.invokePythonMethodOn(self._meth,cPickle.dumps(args,cPickle.HIGHEST_PROTOCOL))
+ return GetHandlerFromRef(ret,True)
+ pass
+
+PyHandlerTypeMap={int:Int,list:List,tuple:Tuple,dict:Dict}
+
+def GetHandlerFromRef(objCorba,isTempVar=False):
+ v=cPickle.loads(objCorba.fetchSerializedContent())
+ if v is None:
+ return None
+ return PyHandlerTypeMap[v.__class__](objCorba,isTempVar)
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+//
+// 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
+//
+// Author : Anthony Geay (EDF R&D)
+
+#ifndef __SALOMESDS_AUTOREFCOUNTPTR_HXX__
+#define __SALOMESDS_AUTOREFCOUNTPTR_HXX__
+
+#include "SALOMESDS_Exception.hxx"
+
+namespace SALOMESDS
+{
+ template<class T>
+ class AutoRefCountPtr
+ {
+ public:
+ AutoRefCountPtr(const AutoRefCountPtr& other):_ptr(0) { referPtr(other._ptr); }
+ AutoRefCountPtr(T *ptr=0):_ptr(ptr) { }
+ ~AutoRefCountPtr() { destroyPtr(); }
+ bool operator==(const AutoRefCountPtr& other) const { return _ptr==other._ptr; }
+ bool operator==(const T *other) const { return _ptr==other; }
+ AutoRefCountPtr &operator=(const AutoRefCountPtr& other) { if(_ptr!=other._ptr) { destroyPtr(); referPtr(other._ptr); } return *this; }
+ AutoRefCountPtr &operator=(T *ptr) { if(_ptr!=ptr) { destroyPtr(); _ptr=ptr; } return *this; }
+ T *operator->() { return _ptr ; }
+ const T *operator->() const { return _ptr; }
+ T& operator*() { return *_ptr; }
+ const T& operator*() const { return *_ptr; }
+ operator T *() { return _ptr; }
+ operator const T *() const { return _ptr; }
+ T *retn() { if(_ptr) _ptr->incrRef(); return _ptr; }
+ private:
+ void referPtr(T *ptr) { _ptr=ptr; if(_ptr) _ptr->incrRef(); }
+ void destroyPtr() { if(_ptr) _ptr->decrRef(); }
+ private:
+ T *_ptr;
+ };
+
+ template<class T, class U>
+ typename SALOMESDS::AutoRefCountPtr<U> DynamicCast(typename SALOMESDS::AutoRefCountPtr<T>& autoSubPtr) throw()
+ {
+ T *subPtr(autoSubPtr);
+ U *ptr(dynamic_cast<U *>(subPtr));
+ typename SALOMESDS::AutoRefCountPtr<U> ret(ptr);
+ if(ptr)
+ ptr->incrRef();
+ return ret;
+ }
+
+ template<class T, class U>
+ typename SALOMESDS::AutoRefCountPtr<U> DynamicCastSafe(typename SALOMESDS::AutoRefCountPtr<T>& autoSubPtr)
+ {
+ T *subPtr(autoSubPtr);
+ U *ptr(dynamic_cast<U *>(subPtr));
+ if(subPtr && !ptr)
+ throw Exception("DynamicCastSafe : U is not a subtype of T !");
+ typename SALOMESDS::AutoRefCountPtr<U> ret(ptr);
+ if(ptr)
+ ptr->incrRef();
+ return ret;
+ }
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_BasicDataServer.hxx"
+#include "SALOMESDS_DataScopeServer.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include <sstream>
+
+using namespace SALOMESDS;
+
+BasicDataServer::BasicDataServer(DataScopeServer *father, const std::string& varName):_father(father),_var_name(varName)
+{
+}
+
+SALOME::DataScopeServer_ptr BasicDataServer::getMyDataScopeServer()
+{
+ CORBA::Object_var obj(getPOA()->servant_to_reference(_father));
+ return SALOME::DataScopeServer::_narrow(obj);
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+char *BasicDataServer::getVarName()
+{
+ return CORBA::string_dup(_var_name.c_str());
+}
+
+char *BasicDataServer::getScopeName()
+{
+ return _father->getScopeName();
+}
+
+void BasicDataServer::Register()
+{
+ incrRef();
+}
+
+void BasicDataServer::UnRegister()
+{
+ decrRef();
+}
+
+void BasicDataServer::Destroy()
+{
+ enforcedRelease();
+}
+
+PortableServer::POA_var BasicDataServer::getPOA()
+{
+ return _father->getPOA();
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_BASICDATASERVER_HXX__
+#define __SALOMESDS_BASICDATASERVER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include "SALOMESDS_RefCountServ.hxx"
+
+#include <string>
+
+namespace SALOMESDS
+{
+ class DataScopeServer;
+
+ class BasicDataServer : public RefCountServ, public virtual POA_SALOME::BasicDataServer
+ {
+ public:
+ BasicDataServer(DataScopeServer *father, const std::string& varName);
+ SALOME::DataScopeServer_ptr getMyDataScopeServer();
+ char *getVarName();
+ char *getScopeName();
+ public:
+ void Register();
+ void UnRegister();
+ void Destroy();
+ public:
+ std::string getVarNameCpp() const { return _var_name; }
+ protected:
+ PortableServer::POA_var getPOA();
+ protected:
+ DataScopeServer *_father;
+ private:
+ std::string _var_name;
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_DataScopeServer.hxx"
+#include "SALOMESDS_DataServerManager.hxx"
+#include "SALOMESDS_PickelizedPyObjRdOnlyServer.hxx"
+#include "SALOMESDS_PickelizedPyObjRdExtServer.hxx"
+#include "SALOMESDS_PickelizedPyObjRdWrServer.hxx"
+#include "SALOME_NamingService.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include <sstream>
+#include <iterator>
+#include <algorithm>
+
+// agy : awful, to be factorized with ContainerManager.
+#ifndef WIN32
+#include <unistd.h>
+#else
+#include <process.h>
+#define getpid _getpid
+#endif
+
+using namespace SALOMESDS;
+
+std::size_t DataScopeServer::COUNTER=0;
+
+DataScopeServer::DataScopeServer(CORBA::ORB_ptr orb, const std::string& scopeName):_globals(0),_locals(0),_pickler(0),_orb(CORBA::ORB::_duplicate(orb)),_name(scopeName)
+{
+}
+
+DataScopeServer::DataScopeServer(const DataScopeServer& other):_globals(0),_locals(0),_pickler(0),_name(other._name),_vars(other._vars)
+{
+}
+
+DataScopeServer::~DataScopeServer()
+{
+ // _globals is borrowed ref -> do nothing
+ Py_XDECREF(_locals);
+ Py_XDECREF(_pickler);
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+void DataScopeServer::ping()
+{
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+char *DataScopeServer::getScopeName()
+{
+ return CORBA::string_dup(_name.c_str());
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+SALOME::StringVec *DataScopeServer::listVars()
+{
+ SALOME::StringVec *ret(new SALOME::StringVec);
+ std::size_t sz(_vars.size());
+ ret->length(sz);
+ 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)[i]=CORBA::string_dup(name.c_str());
+ }
+ return ret;
+}
+
+SALOME::BasicDataServer_ptr DataScopeServer::retrieveVar(const char *varName)
+{
+ std::string varNameCpp(varName);
+ std::vector<std::string> allNames(getAllVarNames());
+ std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varNameCpp));
+ if(it==allNames.end())
+ {
+ std::ostringstream oss; oss << "DataScopeServer::retrieveVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
+ std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
+ throw Exception(oss.str());
+ }
+ std::size_t pos(std::distance(allNames.begin(),it));
+ std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it0(_vars.begin());
+ for(std::size_t i=0;i<pos;i++,it0++);
+ return SALOME::BasicDataServer::_duplicate((*it0).first);
+}
+
+void DataScopeServer::deleteVar(const char *varName)
+{
+ std::string varNameCpp(varName);
+ std::vector<std::string> allNames(getAllVarNames());
+ std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varNameCpp));
+ if(it==allNames.end())
+ {
+ std::ostringstream oss; oss << "DataScopeServer::deleteVar : name \"" << varNameCpp << "\" does not exists ! Possibilities are :";
+ std::copy(allNames.begin(),allNames.end(),std::ostream_iterator<std::string>(oss,", "));
+ throw Exception(oss.str());
+ }
+ std::size_t pos(std::distance(allNames.begin(),it));
+ std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::iterator it0(_vars.begin());
+ (*it0).first->UnRegister();
+ _vars.erase(it0);
+}
+
+SALOME::PickelizedPyObjRdOnlyServer_ptr DataScopeServer::createRdOnlyVar(const char *varName, const SALOME::ByteVec& constValue)
+{
+ std::string varNameCpp(varName);
+ checkNotAlreadyExistingVar(varNameCpp);
+ PickelizedPyObjRdOnlyServer *tmp(new PickelizedPyObjRdOnlyServer(this,varNameCpp,constValue));
+ CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ return SALOME::PickelizedPyObjRdOnlyServer::_narrow(ret);
+}
+
+SALOME::PickelizedPyObjRdExtServer_ptr DataScopeServer::createRdExtVar(const char *varName, const SALOME::ByteVec& constValue)
+{
+ std::string varNameCpp(varName);
+ checkNotAlreadyExistingVar(varNameCpp);
+ PickelizedPyObjRdExtServer *tmp(new PickelizedPyObjRdExtServer(this,varNameCpp,constValue));
+ CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ return SALOME::PickelizedPyObjRdExtServer::_narrow(ret);
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+SALOME::PickelizedPyObjRdWrServer_ptr DataScopeServer::createRdWrVar(const char *typeName, const char *varName)
+{
+ std::string varNameCpp(varName),typeNameCpp(typeName);
+ checkNotAlreadyExistingVar(varNameCpp);
+ PickelizedPyObjRdWrServer *tmp(new PickelizedPyObjRdWrServer(this,typeNameCpp,varNameCpp));
+ CORBA::Object_var ret(activateWithDedicatedPOA(tmp));
+ std::pair< SALOME::BasicDataServer_var, BasicDataServer * > p(SALOME::BasicDataServer::_narrow(ret),tmp);
+ _vars.push_back(p);
+ return SALOME::PickelizedPyObjRdWrServer::_narrow(ret);
+}
+
+void DataScopeServer::shutdownIfNotHostedByDSM()
+{
+ SALOME_NamingService ns(_orb);
+ CORBA::Object_var obj(ns.Resolve(DataServerManager::NAME_IN_NS));
+ SALOME::DataServerManager_var dsm(SALOME::DataServerManager::_narrow(obj));
+ if(CORBA::is_nil(dsm))
+ return ;
+ // destroy ref in the naming service
+ std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
+ ns.Destroy_Name(fullScopeName.c_str());
+ // establish if dsm and this shared the same POA. If yes dsm and this are collocated !
+ PortableServer::ServantBase *ret(0);
+ try
+ {
+ ret=_poa->reference_to_servant(dsm);
+ }
+ catch(...) { ret=0; }
+ //
+ if(!ret)
+ _orb->shutdown(0);
+ else
+ {
+ PortableServer::ObjectId_var oid(_poa->servant_to_id(this));
+ _poa->deactivate_object(oid);
+ ret->_remove_ref();
+ }
+}
+
+void DataScopeServer::initializePython(int argc, char *argv[])
+{
+ Py_Initialize();
+ PySys_SetArgv(argc,argv);
+ PyObject *mainmod(PyImport_AddModule("__main__"));
+ _globals=PyModule_GetDict(mainmod);
+ if(PyDict_GetItemString(_globals, "__builtins__") == NULL)
+ {
+ PyObject *bimod(PyImport_ImportModule("__builtin__"));
+ if (bimod == NULL || PyDict_SetItemString(_globals, "__builtins__", bimod) != 0)
+ Py_FatalError("can't add __builtins__ to __main__");
+ Py_XDECREF(bimod);
+ }
+ _locals=PyDict_New();
+ PyObject *tmp(PyList_New(0));
+ _pickler=PyImport_ImportModuleLevel(const_cast<char *>("cPickle"),_globals,_locals,tmp,-1);
+}
+
+void DataScopeServer::registerToSalomePiDict() const
+{
+ PyObject *mod(PyImport_ImportModule("addToKillList"));
+ if(!mod)
+ return;
+ PyObject *meth(PyObject_GetAttrString(mod,"addToKillList"));
+ if(!meth)
+ { Py_XDECREF(mod); return ; }
+ PyObject *args(PyTuple_New(2));
+ PyTuple_SetItem(args,0,PyInt_FromLong(getpid()));
+ PyTuple_SetItem(args,1,PyString_FromString("SALOME_DataScopeServer"));
+ PyObject *res(PyObject_CallObject(meth,args));
+ Py_XDECREF(args);
+ Py_XDECREF(res);
+ Py_XDECREF(mod);
+}
+
+/*!
+ * \a ptr has been activated by the POA \a poa.
+ */
+void DataScopeServer::setPOAAndRegister(PortableServer::POA_var poa, SALOME::DataScopeServer_ptr ptr)
+{
+ _poa=poa;
+ std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(_name));
+ SALOME_NamingService ns(_orb);
+ ns.Register(ptr,fullScopeName.c_str());
+}
+
+std::string DataScopeServer::BuildTmpVarNameFrom(const std::string& varName)
+{
+ std::ostringstream oss;
+ oss << varName << "@" << COUNTER++;
+ return oss.str();
+}
+
+std::vector< std::string > DataScopeServer::getAllVarNames() const
+{
+ std::size_t sz(_vars.size());
+ std::vector<std::string> ret(sz);
+ std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > >::const_iterator it(_vars.begin());
+ for(std::size_t i=0;i<sz;it++,i++)
+ ret[i]=(*it).second->getVarNameCpp();
+ return ret;
+}
+
+CORBA::Object_var DataScopeServer::activateWithDedicatedPOA(BasicDataServer *ds)
+{
+ PortableServer::ObjectId_var id(_poa->activate_object(ds));
+ CORBA::Object_var ret(_poa->id_to_reference(id));
+ return ret;
+}
+
+void DataScopeServer::checkNotAlreadyExistingVar(const std::string& varName)
+{
+ std::vector<std::string> allNames(getAllVarNames());
+ std::vector<std::string>::iterator it(std::find(allNames.begin(),allNames.end(),varName));
+ if(it!=allNames.end())
+ {
+ std::ostringstream oss; oss << "DataScopeServer::checkNotAlreadyExistingVar : name \"" << varName << "\" already exists !";
+ throw Exception(oss.str());
+ }
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_DATASCOPEERVER_HXX__
+#define __SALOMESDS_DATASCOPEERVER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include "SALOMESDS_RefCountServ.hxx"
+#include "SALOMESDS_AutoRefCountPtr.hxx"
+#include "SALOMESDS_BasicDataServer.hxx"
+
+#include <Python.h>
+
+#include <string>
+#include <vector>
+#include <list>
+
+namespace SALOMESDS
+{
+ class DataScopeServer : public virtual POA_SALOME::DataScopeServer
+ {
+ public:
+ DataScopeServer(CORBA::ORB_ptr orb, const std::string& scopeName);
+ DataScopeServer(const DataScopeServer& other);
+ void ping();
+ char *getScopeName();
+ SALOME::StringVec *listVars();
+ SALOME::BasicDataServer_ptr retrieveVar(const char *varName);
+ void deleteVar(const char *varName);
+ SALOME::PickelizedPyObjRdOnlyServer_ptr createRdOnlyVar(const char *varName, const SALOME::ByteVec& constValue);
+ SALOME::PickelizedPyObjRdExtServer_ptr createRdExtVar(const char *varName, const SALOME::ByteVec& constValue);
+ SALOME::PickelizedPyObjRdWrServer_ptr createRdWrVar(const char *typeName, const char *varName);
+ void shutdownIfNotHostedByDSM();
+ ~DataScopeServer();
+ public:
+ void initializePython(int argc, char *argv[]);
+ void registerToSalomePiDict() const;
+ void setPOAAndRegister(PortableServer::POA_var poa, SALOME::DataScopeServer_ptr ptr);
+ PyObject *getGlobals() const { return _globals; }
+ PyObject *getLocals() const { return _locals; }
+ PyObject *getPickler() const { return _pickler; }
+ PortableServer::POA_var getPOA() { return _poa; }
+ static std::string BuildTmpVarNameFrom(const std::string& varName);
+ private:
+ std::vector< std::string> getAllVarNames() const;
+ CORBA::Object_var activateWithDedicatedPOA(BasicDataServer *ds);
+ void checkNotAlreadyExistingVar(const std::string& varName);
+ private:
+ PyObject *_globals;
+ PyObject *_locals;
+ PyObject *_pickler;
+ PortableServer::POA_var _poa;
+ CORBA::ORB_var _orb;
+ std::string _name;
+ std::list< std::pair< SALOME::BasicDataServer_var, BasicDataServer * > > _vars;
+ static std::size_t COUNTER;
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_DataServerManager.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include "SALOME_ContainerManager.hxx"
+#include "SALOME_NamingService.hxx"
+
+#include <sstream>
+#include <algorithm>
+
+using namespace SALOMESDS;
+
+const char DataServerManager::NAME_IN_NS[]="/DataServerManager";
+
+const char DataServerManager::DFT_SCOPE_NAME_IN_NS[]="Default";
+
+DataServerManager::DataServerManager(int argc, char *argv[], CORBA::ORB_ptr orb, PortableServer::POA_ptr poa):_orb(CORBA::ORB::_duplicate(orb))
+{
+ DataScopeServer *dftScope(new DataScopeServer(orb,DFT_SCOPE_NAME_IN_NS));//_remove_ref will be call by DataScopeServer::shutdownIfNotHostedByDSM
+ PortableServer::POAManager_var pman(poa->the_POAManager());
+ CORBA::PolicyList policies;
+ policies.length(1);
+ PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
+ policies[0]=PortableServer::ThreadPolicy::_duplicate(threadPol);
+ _poa=poa->create_POA("SingleThPOA4SDS",pman,policies);
+ threadPol->destroy();
+ //
+ dftScope->initializePython(argc,argv);// agy : Very important ! invoke this method BEFORE activation !
+ // activate this to be ready to be usable from NS.
+ PortableServer::ObjectId_var id(_poa->activate_object(this));
+ CORBA::Object_var obj(_poa->id_to_reference(id));
+ SALOME::DataServerManager_var obj2(SALOME::DataServerManager::_narrow(obj));
+ // publish Data server manager in NS
+ SALOME_NamingService ns(orb);
+ ns.Register(obj2,NAME_IN_NS);
+ // the default DataScopeServer object is the only one hosted by the current process
+ id=_poa->activate_object(dftScope);
+ obj=_poa->id_to_reference(id);
+ SALOME::DataScopeServer_var dftScopePtr(SALOME::DataScopeServer::_narrow(obj));
+ dftScope->setPOAAndRegister(_poa,dftScopePtr);// agy : Very important ! invoke this method BEFORE activation ! Because this method initializes Python !
+}
+
+SALOME::StringVec *DataServerManager::listScopes()
+{
+ std::vector<std::string> scopes(listOfScopesCpp());
+ SALOME::StringVec *ret(new SALOME::StringVec);
+ std::size_t sz(scopes.size());
+ ret->length(sz);
+ for(std::size_t i=0;i<sz;i++)
+ (*ret)[i]=CORBA::string_dup(scopes[i].c_str());
+ return ret;
+}
+
+SALOME::StringVec *DataServerManager::listAliveAndKickingScopes()
+{
+ std::vector<std::string> scopes(listOfScopesCpp());
+ std::size_t sz(scopes.size());
+ std::vector<std::string> retCpp; retCpp.reserve(sz);
+ for(std::size_t i=0;i<sz;i++)
+ {
+ if(isAliveAndKicking(scopes[i].c_str()))
+ retCpp.push_back(scopes[i]);
+ }
+ //
+ SALOME::StringVec *ret(new SALOME::StringVec);
+ sz=retCpp.size();
+ ret->length(sz);
+ for(std::size_t i=0;i<sz;i++)
+ (*ret)[i]=CORBA::string_dup(retCpp[i].c_str());
+ return ret;
+}
+
+SALOME::DataScopeServer_ptr DataServerManager::getDefaultScope()
+{
+ return retriveDataScope(DFT_SCOPE_NAME_IN_NS);
+}
+
+CORBA::Boolean DataServerManager::isAliveAndKicking(const char *scopeName)
+{
+ SALOME::DataScopeServer_var scopePtr(getScopePtrGivenName(scopeName));
+ CORBA::Boolean ret(true);
+ try
+ {
+ scopePtr->ping();
+ }
+ catch(...)
+ { ret=false; }
+ return ret;
+}
+
+SALOME::DataScopeServer_ptr DataServerManager::createDataScope(const char *scopeName)
+{
+ std::string scopeNameCpp(scopeName);
+ std::vector<std::string> scopes(listOfScopesCpp());
+ if(std::find(scopes.begin(),scopes.end(),scopeNameCpp)!=scopes.end())
+ {
+ std::ostringstream oss; oss << "DataServerManager::createDataScope : scope name \"" << scopeName << "\" already exists !";
+ throw Exception(oss.str());
+ }
+ //
+ SALOME_NamingService ns(_orb);
+ std::string fullScopeName(CreateAbsNameInNSFromScopeName(scopeName));
+ std::ostringstream oss; oss << "SALOME_DataScopeServer" << " " << scopeName << " ";
+ SALOME_ContainerManager::AddOmninamesParams(oss,&ns);
+ std::string command(oss.str());
+ SALOME_ContainerManager::MakeTheCommandToBeLaunchedASync(command);
+ int status(SALOME_ContainerManager::SystemThreadSafe(command.c_str()));
+ int count(SALOME_ContainerManager::GetTimeOutToLoaunchServer());
+ SALOME::DataScopeServer_var ret(SALOME::DataScopeServer::_nil());
+ while (CORBA::is_nil(ret) && count)
+ {
+ SALOME_ContainerManager::SleepInSecond(1);
+ count--;
+ CORBA::Object_var obj(ns.Resolve(fullScopeName.c_str()));
+ ret=SALOME::DataScopeServer::_narrow(obj);
+ }
+ return SALOME::DataScopeServer::_duplicate(ret);
+}
+
+SALOME::DataScopeServer_ptr DataServerManager::giveADataScopeCalled(const char *scopeName, CORBA::Boolean& isCreated)
+{
+ std::string scopeNameCpp(scopeName);
+ std::vector<std::string> scopes(listOfScopesCpp());
+ if(std::find(scopes.begin(),scopes.end(),scopeNameCpp)==scopes.end())
+ {
+ isCreated=true;
+ return createDataScope(scopeName);
+ }
+ else
+ {
+ if(isAliveAndKicking(scopeName))
+ {
+ isCreated=false;
+ return retriveDataScope(scopeName);
+ }
+ else
+ {
+ SALOME_NamingService ns(_orb);
+ std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(scopeNameCpp));
+ ns.Destroy_Name(fullScopeName.c_str());
+ isCreated=true;
+ return createDataScope(scopeName);
+ }
+ }
+}
+
+SALOME::DataScopeServer_ptr DataServerManager::retriveDataScope(const char *scopeName)
+{
+ SALOME::DataScopeServer_var ret(getScopePtrGivenName(scopeName));
+ return SALOME::DataScopeServer::_duplicate(ret);
+}
+
+void DataServerManager::removeDataScope(const char *scopeName)
+{
+ SALOME::DataScopeServer_var scs(getScopePtrGivenName(scopeName));
+ scs->shutdownIfNotHostedByDSM();
+}
+
+void DataServerManager::cleanScopesInNS()
+{
+ SALOME_NamingService ns(_orb);
+ std::vector<std::string> scopes(listOfScopesCpp());
+ for(std::vector<std::string>::const_iterator it=scopes.begin();it!=scopes.end();it++)
+ {
+ if(!isAliveAndKicking((*it).c_str()))
+ {
+ std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(*it));
+ ns.Destroy_Name(fullScopeName.c_str());
+ }
+ }
+}
+
+void DataServerManager::shutdownScopes()
+{
+ std::vector<std::string> scopeNames(listOfScopesCpp());
+ for(std::vector<std::string>::const_iterator it=scopeNames.begin();it!=scopeNames.end();it++)
+ getScopePtrGivenName(*it)->shutdownIfNotHostedByDSM();
+}
+
+std::string DataServerManager::CreateAbsNameInNSFromScopeName(const std::string& scopeName)
+{
+ std::ostringstream oss; oss << NAME_IN_NS << "/" << scopeName;
+ return oss.str();
+}
+
+std::vector<std::string> DataServerManager::listOfScopesCpp()
+{
+ SALOME_NamingService ns(_orb);
+ ns.Change_Directory(NAME_IN_NS);
+ std::vector<std::string> ret(ns.list_directory());
+ return ret;
+}
+
+SALOME::DataScopeServer_var DataServerManager::getScopePtrGivenName(const std::string& scopeName)
+{
+ std::vector<std::string> scopes(listOfScopesCpp());
+ std::size_t sz(scopes.size());
+ if(std::find(scopes.begin(),scopes.end(),scopeName)==scopes.end())
+ {
+ std::ostringstream oss; oss << "DataServerManager::getScopePtrGivenName : scope name \"" << scopeName << "\" does not exist !";
+ throw Exception(oss.str());
+ }
+ SALOME_NamingService ns(_orb);
+ std::string fullScopeName(CreateAbsNameInNSFromScopeName(scopeName));
+ CORBA::Object_var obj(ns.Resolve(fullScopeName.c_str()));
+ SALOME::DataScopeServer_var ret(SALOME::DataScopeServer::_narrow(obj));
+ return ret;
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_DATASERVERMANAGER_HXX__
+#define __SALOMESDS_DATASERVERMANAGER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include "SALOMESDS_AutoRefCountPtr.hxx"
+#include "SALOMESDS_DataScopeServer.hxx"
+
+#include <string>
+
+namespace SALOMESDS
+{
+ class DataScopeServer;
+
+ class DataServerManager : public virtual POA_SALOME::DataServerManager
+ {
+ public:
+ DataServerManager(int argc, char *argv[], CORBA::ORB_ptr orb, PortableServer::POA_ptr poa);
+ SALOME::StringVec *listScopes();
+ SALOME::StringVec *listAliveAndKickingScopes();
+ SALOME::DataScopeServer_ptr getDefaultScope();
+ CORBA::Boolean isAliveAndKicking(const char *scopeName);
+ SALOME::DataScopeServer_ptr createDataScope(const char *scopeName);
+ SALOME::DataScopeServer_ptr retriveDataScope(const char *scopeName);
+ SALOME::DataScopeServer_ptr giveADataScopeCalled(const char *scopeName, CORBA::Boolean& isCreated);
+ void removeDataScope(const char *scopeName);
+ void cleanScopesInNS();
+ void shutdownScopes();
+ static std::string CreateAbsNameInNSFromScopeName(const std::string& scopeName);
+ public:
+ static const char NAME_IN_NS[];
+ static const char DFT_SCOPE_NAME_IN_NS[];
+ private:
+ std::vector<std::string> listOfScopesCpp();
+ SALOME::DataScopeServer_var getScopePtrGivenName(const std::string& scopeName);
+ private:
+ CORBA::ORB_var _orb;
+ //! single thread poa
+ PortableServer::POA_var _poa;
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_Exception.hxx"
+
+SALOMESDS::Exception::Exception(const std::string& reason)
+{
+ SALOME::ExceptionStruct es;
+ es.type=SALOME::INTERNAL_ERROR;
+ es.text=CORBA::string_dup(reason.c_str());
+ es.lineNumber=0;
+ (*this).details=es;
+}
+
+
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_EXCEPTION_HXX__
+#define __SALOMESDS_EXCEPTION_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_Exception)
+
+#include <string>
+
+namespace SALOMESDS
+{
+ class Exception : public SALOME::SALOME_Exception
+ {
+ public:
+ Exception(const std::string& reason);
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_PickelizedPyObjRdExtServer.hxx"
+#include "SALOMESDS_DataScopeServer.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include <iostream>
+#include <sstream>
+
+using namespace SALOMESDS;
+
+PickelizedPyObjRdExtServer::PickelizedPyObjRdExtServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value):PickelizedPyObjServer(father,varName,value)
+{
+}
+
+//! obj is consumed
+PickelizedPyObjRdExtServer::PickelizedPyObjRdExtServer(DataScopeServer *father, const std::string& varName, PyObject *obj):PickelizedPyObjServer(father,varName,obj)
+{
+}
+
+PickelizedPyObjRdExtServer::~PickelizedPyObjRdExtServer()
+{
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+SALOME::PickelizedPyObjRdExtServer_ptr PickelizedPyObjRdExtServer::invokePythonMethodOn(const char *method, const SALOME::ByteVec& args)
+{
+ if(!_self)
+ throw Exception("PickelizedPyObjRdExtServer::invokePythonMethodOn : self is NULL !");
+ std::string argsCpp;
+ FromByteSeqToCpp(args,argsCpp);
+ PyObject *argsPy(getPyObjFromPickled(argsCpp));
+ checkRdExtnessOf(method,argsPy);
+ //
+ PyObject *selfMeth(PyObject_GetAttrString(_self,method));
+ if(!selfMeth)
+ {
+ std::ostringstream oss; oss << "PickelizedPyObjRdExtServer::invokePythonMethodOn : Method \"" << method << "\" is not available !";
+ throw Exception(oss.str());
+ }
+ PyObject *res(PyObject_CallObject(selfMeth,argsPy));// self can have been modified by this call !
+ Py_XDECREF(selfMeth);
+ Py_XDECREF(argsPy);
+ if(!res)
+ {
+ std::ostringstream oss; oss << "PickelizedPyObjRdExtServer::invokePythonMethodOn : Problem during invokation serverside of Method \"" << method << "\" !";
+ throw Exception(oss.str());
+ }
+ PickelizedPyObjRdExtServer *ret(new PickelizedPyObjRdExtServer(_father,DataScopeServer::BuildTmpVarNameFrom(getVarNameCpp()),res));
+ PortableServer::POA_var poa(_father->getPOA());
+ PortableServer::ObjectId_var id(poa->activate_object(ret));
+ CORBA::Object_var obj(poa->id_to_reference(id));
+ return SALOME::PickelizedPyObjRdExtServer::_narrow(obj);
+}
+
+void PickelizedPyObjRdExtServer::checkRdExtnessOf(const std::string& methodName, PyObject *argsPy)
+{
+ if(!_self)
+ {
+ Py_XDECREF(argsPy);
+ throw Exception("PickelizedPyObjRdExtServer::checkRdExtnessOf : self is NULL !");
+ }
+ if(PyTuple_Check(_self)==1 || PyString_Check(_self)==1 || PyInt_Check(_self)==1 || PyBool_Check(_self)==1 || PyFloat_Check(_self)==1)
+ return ;//_self is tuple, str, int or float -> immutable in python. So no method can break the RdExtness of _self.
+ if(PyList_Check(_self)==1)
+ checkListRdExtnessOf(methodName,argsPy);
+ else if(PyDict_Check(_self)==1)
+ checkDictRdExtnessOf(methodName,argsPy);
+ else
+ throw Exception("PickelizedPyObjRdExtServer::checkRdExtnessOf : Supported python types are [list,tuple,dict,str,int,float] !");
+}
+
+void PickelizedPyObjRdExtServer::checkListRdExtnessOf(const std::string& methodName, PyObject *argsPy)
+{
+ static const char *THE_RDEXT_METH_OF_LIST[]={"__getitem__","append","extend","insert","reverse","sort"};
+ for(std::size_t i=0;i<sizeof(THE_RDEXT_METH_OF_LIST)/sizeof(const char *);i++)
+ if(methodName==THE_RDEXT_METH_OF_LIST[i])
+ return ;
+ Py_XDECREF(argsPy);
+ std::ostringstream oss; oss << "PickelizedPyObjRdExtServer::checkListRdExtnessOf : The method \"" << methodName << "\" is a method that can lead to a loss of data ! Supported method of \"list \"without loss of data are : __getitem__, append, extend, insert, reverse, sort !";
+ throw Exception(oss.str());
+}
+
+void PickelizedPyObjRdExtServer::checkDictRdExtnessOf(const std::string& methodName, PyObject *argsPy)
+{
+ static const char *THE_RDEXT_METH_OF_DICT[]={"__getitem__","get","items","keys","setdefault","update","values"};
+ for(std::size_t i=0;i<sizeof(THE_RDEXT_METH_OF_DICT)/sizeof(const char *);i++)
+ if(methodName==THE_RDEXT_METH_OF_DICT[i])
+ return ;
+ if(methodName=="__setitem__")
+ {
+ checkDictSetitemRdExtness(argsPy);
+ return ;
+ }
+ Py_XDECREF(argsPy);
+ std::ostringstream oss; oss << "PickelizedPyObjRdExtServer::checkDictRdExtnessOf : The method \"" << methodName << "\" is a method that can lead to a loss of data ! Supported method of \"list \"without loss of data are : __getitem__, __setitem__(with conditions), get, items, keys, setdefault, update, values !";
+ throw Exception(oss.str());
+}
+
+void PickelizedPyObjRdExtServer::checkDictSetitemRdExtness(PyObject *argsPy)
+{
+ if(PyTuple_Check(argsPy)==0)
+ {
+ Py_XDECREF(argsPy);
+ throw Exception("PickelizedPyObjRdExtServer::checkDictSetitemRdExtness : args of dic(self).__setitem__ is not a tuple !");
+ }
+ if(PyTuple_Size(argsPy)!=2)
+ {
+ Py_XDECREF(argsPy);
+ throw Exception("PickelizedPyObjRdExtServer::checkDictSetitemRdExtness : tuple of dic(self).__setitem__ has not a size equal to 2 !");
+ }
+ if(PyDict_GetItem(_self,PyTuple_GetItem(argsPy,0))!=0)
+ {// argsPy[0] is already a key of _self -> __setitem__ is NOT RdExt !
+ Py_XDECREF(argsPy);
+ throw Exception("PickelizedPyObjRdExtServer::checkDictSetitemRdExtness : specified key of __setitem__ already exists ! RdExt property is not applied !");
+ }
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_PICKELIZEDPYOBJRDEXTSERVER_HXX__
+#define __SALOMESDS_PICKELIZEDPYOBJRDEXTSERVER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include <Python.h>
+
+#include "SALOMESDS_PickelizedPyObjServer.hxx"
+
+namespace SALOMESDS
+{
+ class PickelizedPyObjRdExtServer : public PickelizedPyObjServer, public virtual POA_SALOME::PickelizedPyObjRdExtServer
+ {
+ public:
+ PickelizedPyObjRdExtServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value);
+ PickelizedPyObjRdExtServer(DataScopeServer *father, const std::string& varName, PyObject *obj);
+ ~PickelizedPyObjRdExtServer();
+ SALOME::PickelizedPyObjRdExtServer_ptr invokePythonMethodOn(const char *method, const SALOME::ByteVec& args);
+ private:
+ void checkRdExtnessOf(const std::string& methodName, PyObject *argsPy);
+ void checkListRdExtnessOf(const std::string& methodName, PyObject *argsPy);
+ void checkDictRdExtnessOf(const std::string& methodName, PyObject *argsPy);
+ void checkDictSetitemRdExtness(PyObject *argsPy);
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_PickelizedPyObjRdOnlyServer.hxx"
+
+using namespace SALOMESDS;
+
+PickelizedPyObjRdOnlyServer::PickelizedPyObjRdOnlyServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value):PickelizedPyObjServer(father,varName,value)
+{
+}
+
+PickelizedPyObjRdOnlyServer::PickelizedPyObjRdOnlyServer(DataScopeServer *father, const std::string& varName, PyObject *obj):PickelizedPyObjServer(father,varName,obj)
+{
+}
+
+PickelizedPyObjRdOnlyServer::~PickelizedPyObjRdOnlyServer()
+{
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_PICKELIZEDPYOBJRDONLYSERVER_HXX__
+#define __SALOMESDS_PICKELIZEDPYOBJRDONLYSERVER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include <Python.h>
+
+#include "SALOMESDS_PickelizedPyObjServer.hxx"
+
+namespace SALOMESDS
+{
+ class PickelizedPyObjRdOnlyServer : public PickelizedPyObjServer, public virtual POA_SALOME::PickelizedPyObjRdOnlyServer
+ {
+ public:
+ PickelizedPyObjRdOnlyServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value);
+ PickelizedPyObjRdOnlyServer(DataScopeServer *father, const std::string& varName, PyObject *obj);
+ ~PickelizedPyObjRdOnlyServer();
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_PickelizedPyObjRdWrServer.hxx"
+#include "SALOMESDS_DataScopeServer.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include <iostream>
+#include <sstream>
+
+using namespace SALOMESDS;
+
+PickelizedPyObjRdWrServer::PickelizedPyObjRdWrServer(DataScopeServer *father, const std::string& typeName, const std::string& varName):PickelizedPyObjServer(father,varName,CreateDftObjFromType(father->getGlobals(),typeName))
+{
+}
+
+PickelizedPyObjRdWrServer::PickelizedPyObjRdWrServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value):PickelizedPyObjServer(father,varName,value)
+{
+}
+
+//! obj is consumed
+PickelizedPyObjRdWrServer::PickelizedPyObjRdWrServer(DataScopeServer *father, const std::string& varName, PyObject *obj):PickelizedPyObjServer(father,varName,obj)
+{
+}
+
+PickelizedPyObjRdWrServer::~PickelizedPyObjRdWrServer()
+{
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+void PickelizedPyObjRdWrServer::setSerializedContent(const SALOME::ByteVec& newValue)
+{
+ setSerializedContentInternal(newValue);
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+SALOME::PickelizedPyObjRdWrServer_ptr PickelizedPyObjRdWrServer::invokePythonMethodOn(const char *method, const SALOME::ByteVec& args)
+{
+ if(!_self)
+ throw Exception("PickelizedPyObjRdWrServer::invokePythonMethodOn : self is NULL !");
+ std::string argsCpp;
+ FromByteSeqToCpp(args,argsCpp);
+ PyObject *argsPy(getPyObjFromPickled(argsCpp));
+ //
+ PyObject *selfMeth(PyObject_GetAttrString(_self,method));
+ if(!selfMeth)
+ {
+ std::ostringstream oss; oss << "PickelizedPyObjRdWrServer::invokePythonMethodOn : Method \"" << method << "\" is not available !";
+ throw Exception(oss.str());
+ }
+ PyObject *res(PyObject_CallObject(selfMeth,argsPy));// self can have been modified by this call !
+ Py_XDECREF(selfMeth);
+ Py_XDECREF(argsPy);
+ if(!res)
+ {
+ std::ostringstream oss,oss2,oss3;
+ PyObject *errTyp(0),*errValue(0),*errTB(0);
+ PyErr_Fetch(&errTyp,&errValue,&errTB);
+ oss2 << "(";
+ if(errTyp)
+ {
+ PyObject *ob(PyObject_Str(errTyp));
+ oss2 << " type : \"" << (const char *)PyString_AsString(ob) << "\"";
+ Py_XDECREF(ob); Py_XDECREF(errTyp);
+ }
+ if(errValue)
+ {
+ PyObject *ob(PyObject_Str(errValue));
+ oss2 << " value : \"" << (const char *)PyString_AsString(ob) << "\"";
+ Py_XDECREF(ob); Py_XDECREF(errValue);
+ }
+ oss2 << " )";
+ if(errTB)
+ {
+ PyObject *ob(PyObject_Str(errTB));
+ oss2 << "( traceback : \"" << (const char *)PyString_AsString(ob) << "\"";
+ Py_XDECREF(ob); Py_XDECREF(errTB);
+ }
+ oss2 << " )";
+ PyErr_Clear();
+ oss << "PickelizedPyObjRdWrServer::invokePythonMethodOn : Problem during invokation serverside of Method \"" << method << "\" ! Details are : " << oss2.str() << "\n\n" << "TraceBack is : " << oss3.str();
+ throw Exception(oss.str());
+ }
+ PickelizedPyObjRdWrServer *ret(new PickelizedPyObjRdWrServer(_father,DataScopeServer::BuildTmpVarNameFrom(getVarNameCpp()),res));
+ PortableServer::POA_var poa(_father->getPOA());
+ PortableServer::ObjectId_var id(poa->activate_object(ret));
+ CORBA::Object_var obj(poa->id_to_reference(id));
+ return SALOME::PickelizedPyObjRdWrServer::_narrow(obj);
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_PICKELIZEDPYOBJRDWRSERVER_HXX__
+#define __SALOMESDS_PICKELIZEDPYOBJRDWRSERVER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include <Python.h>
+
+#include "SALOMESDS_PickelizedPyObjServer.hxx"
+
+namespace SALOMESDS
+{
+ class PickelizedPyObjRdWrServer : public PickelizedPyObjServer, public virtual POA_SALOME::PickelizedPyObjRdWrServer
+ {
+ public:
+ PickelizedPyObjRdWrServer(DataScopeServer *father, const std::string& typeName, const std::string& varName);
+ PickelizedPyObjRdWrServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value);
+ PickelizedPyObjRdWrServer(DataScopeServer *father, const std::string& varName, PyObject *obj);
+ ~PickelizedPyObjRdWrServer();
+ void setSerializedContent(const SALOME::ByteVec& newValue);
+ SALOME::PickelizedPyObjRdWrServer_ptr invokePythonMethodOn(const char *method, const SALOME::ByteVec& args);
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_PickelizedPyObjServer.hxx"
+#include "SALOMESDS_DataScopeServer.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include <iostream>
+#include <sstream>
+
+using namespace SALOMESDS;
+
+PickelizedPyObjServer::PickelizedPyObjServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value):BasicDataServer(father,varName),_self(0)
+{
+ setSerializedContentInternal(value);
+}
+
+//! obj is consumed
+PickelizedPyObjServer::PickelizedPyObjServer(DataScopeServer *father, const std::string& varName, PyObject *obj):BasicDataServer(father,varName),_self(0)
+{
+ setNewPyObj(obj);
+}
+
+PickelizedPyObjServer::~PickelizedPyObjServer()
+{
+ Py_XDECREF(_self);
+}
+
+/*!
+ * Called remotely -> to protect against throw
+ */
+SALOME::ByteVec *PickelizedPyObjServer::fetchSerializedContent()
+{
+ Py_XINCREF(_self);//because pickelize consume _self
+ return FromCppToByteSeq(pickelize(_self));
+}
+
+void PickelizedPyObjServer::FromByteSeqToCpp(const SALOME::ByteVec& bsToBeConv, std::string& ret)
+{
+ std::size_t sz(bsToBeConv.length());
+ ret.resize(sz,' ');
+ char *buf(const_cast<char *>(ret.c_str()));
+ for(std::size_t i=0;i<sz;i++)
+ buf[i]=bsToBeConv[i];
+}
+
+SALOME::ByteVec *PickelizedPyObjServer::FromCppToByteSeq(const std::string& strToBeConv)
+{
+ SALOME::ByteVec *ret(new SALOME::ByteVec);
+ const char *buf(strToBeConv.c_str());
+ std::size_t sz(strToBeConv.size());
+ ret->length(sz);
+ for(std::size_t i=0;i<sz;i++)
+ (*ret)[i]=buf[i];
+ return ret;
+}
+
+//! New reference returned
+PyObject *PickelizedPyObjServer::getPyObjFromPickled(const std::string& pickledData)
+{
+ std::size_t sz(pickledData.size());
+ PyObject *pickledDataPy(PyString_FromStringAndSize(NULL,sz));// agy : do not use PyString_FromString because std::string hides a vector of byte.
+ char *buf(PyString_AsString(pickledDataPy));// this buf can be used thanks to python documentation.
+ const char *inBuf(pickledData.c_str());
+ std::copy(inBuf,inBuf+sz,buf);
+ PyObject *selfMeth(PyObject_GetAttrString(_father->getPickler(),"loads"));
+ PyObject *args(PyTuple_New(1)); PyTuple_SetItem(args,0,pickledDataPy);
+ PyObject *ret(PyObject_CallObject(selfMeth,args));
+ Py_XDECREF(args);
+ Py_XDECREF(selfMeth);
+ return ret;
+}
+
+//! obj is consumed by this method.
+std::string PickelizedPyObjServer::pickelize(PyObject *obj)
+{
+ PyObject *args(PyTuple_New(2));
+ PyTuple_SetItem(args,0,obj);
+ PyTuple_SetItem(args,1,PyInt_FromLong(2));// because "assert(cPickle.HIGHEST_PROTOCOL is 2)"
+ PyObject *selfMeth(PyObject_GetAttrString(_father->getPickler(),"dumps"));
+ PyObject *retPy(PyObject_CallObject(selfMeth,args));
+ Py_XDECREF(selfMeth);
+ Py_XDECREF(args);
+ std::size_t sz(PyString_Size(retPy));
+ std::string ret(sz,'\0');
+ const char *buf(PyString_AsString(retPy));
+ char *inBuf(const_cast<char *>(ret.c_str()));
+ for(std::size_t i=0;i<sz;i++)
+ inBuf[i]=buf[i];
+ Py_XDECREF(retPy);
+ return ret;
+}
+
+//! obj is consumed by this method.
+void PickelizedPyObjServer::setNewPyObj(PyObject *obj)
+{
+ if(!obj)
+ throw Exception("PickelizedPyObjServer::setNewPyObj : trying to assign a NULL pyobject in this !");
+ if(obj==_self)
+ return ;
+ if(PyList_Check(obj)==0 && PyDict_Check(obj)==0 && PyTuple_Check(obj)==0 && PyString_Check(obj)==0 && PyInt_Check(obj)==0 && PyBool_Check(obj)==0 && PyFloat_Check(obj)==0 && obj!=Py_None)
+ throw Exception("PickelizedPyObjServer::setNewPyObj : Supported python types are [list,tuple,dict,str,int,bool,float,None] !");
+ if(_self)
+ {
+ PyObject *selfType(PyObject_Type(_self));
+ if(PyObject_IsInstance(obj,selfType)!=1)
+ {
+ Py_XDECREF(obj);
+ Py_XDECREF(selfType);
+ throw Exception("PickelizedPyObjServer::setNewPyObj : type of new object is not the same than those previously set !");
+ }
+ else
+ Py_XDECREF(selfType);
+ }
+ Py_XDECREF(_self);
+ _self=obj;
+}
+
+void PickelizedPyObjServer::setSerializedContentInternal(const SALOME::ByteVec& newValue)
+{
+ std::string data;
+ FromByteSeqToCpp(newValue,data);
+ setNewPyObj(getPyObjFromPickled(data));
+}
+
+PyObject *PickelizedPyObjServer::CreateDftObjFromType(PyObject *globals, const std::string& typeName)
+{
+ PyObject *builtins(PyDict_GetItemString(globals,"__builtins__"));
+ if(!builtins)
+ throw Exception("PickelizedPyObjServer constructor : no __builtins__ in globals !");
+ PyObject *builtins2(PyModule_GetDict(builtins));
+ if(!builtins2)
+ throw Exception("PickelizedPyObjServer constructor : internal error fail to invoke __dict__ on __builtins__ !");
+ PyObject *tmp(PyDict_GetItemString(builtins2,typeName.c_str()));
+ if(!tmp)
+ {
+ std::ostringstream oss; oss << "PickelizedPyObjServer::CreateDftObjFromType : Invalid type name \"" << typeName << "\" !";
+ throw Exception(oss.str());
+ }
+ PyObject *args(PyTuple_New(0));
+ PyObject *ret(PyObject_CallObject(tmp,args));
+ Py_XDECREF(args);
+ return ret;
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_PICKELIZEDPYOBJSERVER_HXX__
+#define __SALOMESDS_PICKELIZEDPYOBJSERVER_HXX__
+
+#include "SALOMEconfig.h"
+#include CORBA_SERVER_HEADER(SALOME_SDS)
+
+#include <Python.h>
+
+#include "SALOMESDS_BasicDataServer.hxx"
+
+namespace SALOMESDS
+{
+ class PickelizedPyObjServer : public BasicDataServer, public virtual POA_SALOME::PickelizedPyObjServer
+ {
+ public:
+ PickelizedPyObjServer(DataScopeServer *father, const std::string& varName, const SALOME::ByteVec& value);
+ PickelizedPyObjServer(DataScopeServer *father, const std::string& varName, PyObject *obj);
+ ~PickelizedPyObjServer();
+ void setSerializedContent(const SALOME::ByteVec& newValue);
+ SALOME::ByteVec *fetchSerializedContent();
+ protected:
+ static void FromByteSeqToCpp(const SALOME::ByteVec& bsToBeConv, std::string& ret);
+ static SALOME::ByteVec *FromCppToByteSeq(const std::string& strToBeConv);
+ PyObject *getPyObjFromPickled(const std::string& pickledData);
+ std::string pickelize(PyObject *obj);
+ void setNewPyObj(PyObject *obj);
+ void setSerializedContentInternal(const SALOME::ByteVec& newValue);
+ static PyObject *CreateDftObjFromType(PyObject *globals, const std::string& typeName);
+ protected:
+ static const char FAKE_VAR_NAME_FOR_WORK[];
+ PyObject *_self;
+ PortableServer::POA_var _poa;
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_RefCountServ.hxx"
+
+using namespace SALOMESDS;
+
+void RefCountServ::incrRef() const
+{
+ _cnt++;
+}
+
+bool RefCountServ::decrRef() const
+{
+ bool ret((--_cnt)==0);
+ if(ret)
+ {
+ RefCountServ *thisNC(const_cast<RefCountServ *>(this));
+ thisNC->enforcedRelease();
+ }
+ return ret;
+}
+
+void RefCountServ::enforcedRelease()
+{
+ PortableServer::POA_var poa(getPOA());
+ PortableServer::ObjectId_var oid(poa->servant_to_id(this));
+ poa->deactivate_object(oid);
+ _remove_ref();
+}
+
+RefCountServ::RefCountServ():_cnt(1)
+{
+}
+
+RefCountServ::RefCountServ(const RefCountServ& other):_cnt(1)
+{
+}
+
+RefCountServ::~RefCountServ()
+{
+}
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#ifndef __SALOMESDS_REFCOUNTSERV_HXX__
+#define __SALOMESDS_REFCOUNTSERV_HXX__
+
+#include <omniORB4/CORBA.h>
+
+namespace SALOMESDS
+{
+ class RefCountServ : public virtual PortableServer::ServantBase
+ {
+ public:
+ void incrRef() const;
+ bool decrRef() const;
+ virtual PortableServer::POA_var getPOA() = 0;
+ protected:
+ void enforcedRelease();
+ RefCountServ();
+ RefCountServ(const RefCountServ& other);
+ virtual ~RefCountServ();
+ private:
+ mutable unsigned int _cnt;
+ };
+}
+
+#endif
--- /dev/null
+// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// Author : Anthony GEAY (EDF R&D)
+
+#include "SALOMESDS_DataScopeServer.hxx"
+#include "SALOMESDS_DataServerManager.hxx"
+#include "SALOMESDS_Exception.hxx"
+
+#include "SALOME_NamingService.hxx"
+
+#include <string>
+#include <sstream>
+
+int main(int argc, char *argv[])
+{
+ std::string scopeName;
+ if(argc<=1)
+ throw SALOMESDS::Exception("In the main of SALOME_DataScopeServer.cxx !");
+ scopeName=argv[1];
+ CORBA::ORB_var orb(CORBA::ORB_init(argc,argv));
+ CORBA::Object_var obj(orb->resolve_initial_references("RootPOA"));
+ PortableServer::POA_var poa(PortableServer::POA::_narrow(obj));
+ PortableServer::POAManager_var mgr(poa->the_POAManager());
+ mgr->activate();
+ SALOMESDS::DataScopeServer *server(new SALOMESDS::DataScopeServer(orb,scopeName));
+ //
+ CORBA::PolicyList policies;
+ policies.length(1);
+ PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
+ policies[0]=PortableServer::ThreadPolicy::_duplicate(threadPol);
+ PortableServer::POA_var poa2(poa->create_POA("SingleThPOA4SDS",mgr,policies));
+ threadPol->destroy();
+ server->initializePython(argc,argv);// agy : Very important ! invoke this method BEFORE activation !
+ server->registerToSalomePiDict();
+ PortableServer::ObjectId_var id(poa2->activate_object(server));
+ obj=poa2->id_to_reference(id);
+ SALOME::DataScopeServer_var serverPtr(SALOME::DataScopeServer::_narrow(obj));
+ server->setPOAAndRegister(poa2,serverPtr);
+ //
+ orb->run();
+ server->_remove_ref();
+ return 0;
+}
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+#
+# 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
+#
+# Author : Anthony Geay
+
+import SALOME
+import cPickle
+
+class WrappedType(object):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ assert(isinstance(varPtr,SALOME._objref_PickelizedPyObjServer))
+ self._var_ptr=varPtr
+ if not isTemporaryVar:
+ self._var_ptr.Register()
+ self._is_temp=isTemporaryVar
+ pass
+
+ def local_copy(self):
+ return cPickle.loads(self._var_ptr.fetchSerializedContent())
+
+ def __str__(self):
+ return self.local_copy().__str__()
+
+ def __repr__(self):
+ return self.local_copy().__repr__()
+
+ def __reduce__(self):
+ return (self._wrapped_type,(self.local_copy(),))
+
+ def assign(self,elt):
+ assert(isinstance(self._var_ptr,SALOME._objref_PickelizedPyObjRdWrServer))
+ st=cPickle.dumps(elt,cPickle.HIGHEST_PROTOCOL)
+ self._var_ptr.setSerializedContent(st)
+ pass
+
+ def __del__(self):
+ self._var_ptr.UnRegister()
+ pass
+ pass
+
+class List(WrappedType):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ WrappedType.__init__(self,varPtr,isTemporaryVar)
+ self._wrapped_type=list
+ pass
+
+ def __getitem__(self,*args):
+ ret=Caller(self._var_ptr,"__getitem__")
+ return ret(*args)
+
+ def __setitem__(self,*args):
+ ret=Caller(self._var_ptr,"__setitem__")
+ return ret(*args)
+
+ def __delitem__(self,*args):
+ ret=Caller(self._var_ptr,"__delitem__")
+ return ret(*args)
+
+ def append(self,*args):
+ ret=Caller(self._var_ptr,"append")
+ return ret(*args)
+
+ def extend(self,*args):
+ ret=Caller(self._var_ptr,"extend")
+ return ret(*args)
+
+ def insert(self,*args):
+ ret=Caller(self._var_ptr,"insert")
+ return ret(*args)
+
+ def pop(self,*args):
+ ret=Caller(self._var_ptr,"pop")
+ return ret(*args)
+
+ def remove(self,*args):
+ ret=Caller(self._var_ptr,"remove")
+ return ret(*args)
+
+ def reverse(self,*args):
+ ret=Caller(self._var_ptr,"reverse")
+ return ret(*args)
+
+ def sort(self,*args):
+ ret=Caller(self._var_ptr,"sort")
+ return ret(*args)
+
+ def count(self,*args):
+ return self.local_copy().count(*args)
+
+ def index(self,*args):
+ return self.local_copy().index(*args)
+
+ def __len__(self):
+ return len(self.local_copy())
+ pass
+
+class Dict(WrappedType):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ WrappedType.__init__(self,varPtr,isTemporaryVar)
+ self._wrapped_type=dict
+ pass
+
+ def __getitem__(self,*args):
+ ret=Caller(self._var_ptr,"__getitem__")
+ return ret(*args)
+
+ def __setitem__(self,*args):
+ ret=Caller(self._var_ptr,"__setitem__")
+ return ret(*args)
+
+ def __delitem__(self,*args):
+ ret=Caller(self._var_ptr,"__delitem__")
+ return ret(*args)
+
+ def clear(self,*args):
+ ret=Caller(self._var_ptr,"clear")
+ return ret(*args)
+
+ def get(self,*args):
+ ret=Caller(self._var_ptr,"get")
+ return ret(*args)
+
+ def items(self,*args):
+ ret=Caller(self._var_ptr,"items")
+ return ret(*args)
+
+ def pop(self,*args):
+ ret=Caller(self._var_ptr,"pop")
+ return ret(*args)
+
+ def popitem(self,*args):
+ ret=Caller(self._var_ptr,"popitem")
+ return ret(*args)
+
+ def setdefault(self,*args):
+ ret=Caller(self._var_ptr,"setdefault")
+ return ret(*args)
+
+ def update(self,*args):
+ ret=Caller(self._var_ptr,"update")
+ return ret(*args)
+
+ def values(self,*args):
+ ret=Caller(self._var_ptr,"values")
+ return ret(*args)
+
+ # work on local copy
+
+ def __contains__(self,*args):
+ return self.local_copy().__contains__(*args)
+
+ def has_key(self,*args):
+ return self.local_copy().has_key(*args)
+
+ def keys(self,*args):
+ return self.local_copy().keys(*args)
+
+ def copy(self,*args):
+ return self.local_copy().copy(*args)
+
+ def __len__(self):
+ return len(self.local_copy())
+
+ pass
+
+class Tuple(WrappedType):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ WrappedType.__init__(self,varPtr,isTemporaryVar)
+ self._wrapped_type=tuple
+ pass
+
+ def __getitem__(self,*args):
+ ret=Caller(self._var_ptr,"__getitem__")
+ return ret(*args)
+
+ # work on local copy
+
+ def count(self,*args):
+ return self.local_copy().count(*args)
+
+ def index(self,*args):
+ return self.local_copy().index(*args)
+
+ def __len__(self):
+ return len(self.local_copy())
+
+ pass
+
+class Float(WrappedType):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ WrappedType.__init__(self,varPtr,isTemporaryVar)
+ self._wrapped_type=float
+ pass
+
+ def __iadd__(self,*args):
+ return self.local_copy().__add__(*args)
+
+ def __isub__(self,*args):
+ return self.local_copy().__sub__(*args)
+
+ def __imul__(self,*args):
+ return self.local_copy().__mul__(*args)
+
+ def __idiv__(self,*args):
+ return self.local_copy().__div__(*args)
+
+ def __add__(self,*args):
+ return self.local_copy().__add__(*args)
+
+ def __sub__(self,*args):
+ return self.local_copy().__sub__(*args)
+
+ def __mul__(self,*args):
+ return self.local_copy().__mul__(*args)
+
+ def __div__(self,*args):
+ return self.local_copy().__div__(*args)
+
+ def __pow__(self,*args):
+ return self.local_copy().__pow__(*args)
+
+ def as_integer_ratio(self,*args):
+ return self.local_copy().as_integer_ratio(*args)
+
+ def conjugate(self,*args):
+ return self.local_copy().conjugate(*args)
+
+ def fromhex(self,*args):
+ return self.local_copy().fromhex(*args)
+
+ def hex(self,*args):
+ return self.local_copy().hex(*args)
+
+ def imag(self,*args):
+ return self.local_copy().imag(*args)
+
+ def is_integer(self,*args):
+ return self.local_copy().is_integer(*args)
+
+ def real(self,*args):
+ return self.local_copy().real(*args)
+ pass
+
+class Int(WrappedType):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ WrappedType.__init__(self,varPtr,isTemporaryVar)
+ self._wrapped_type=int
+ pass
+
+ def __iadd__(self,*args):
+ return self.local_copy().__add__(*args)
+
+ def __isub__(self,*args):
+ return self.local_copy().__sub__(*args)
+
+ def __imul__(self,*args):
+ return self.local_copy().__mul__(*args)
+
+ def __imod__(self,*args):
+ return self.local_copy().__mod__(*args)
+
+ def __idiv__(self,*args):
+ return self.local_copy().__div__(*args)
+
+ def __add__(self,*args):
+ return self.local_copy().__add__(*args)
+
+ def __sub__(self,*args):
+ return self.local_copy().__sub__(*args)
+
+ def __mul__(self,*args):
+ return self.local_copy().__mul__(*args)
+
+ def __mod__(self,*args):
+ return self.local_copy().__mod__(*args)
+
+ def __div__(self,*args):
+ return self.local_copy().__div__(*args)
+
+ def __pow__(self,*args):
+ return self.local_copy().__pow__(*args)
+
+ def bit_length(self,*args):
+ return self.local_copy().bit_length(*args)
+
+ def conjugate(self,*args):
+ return self.local_copy().conjugate(*args)
+
+ def denominator(self,*args):
+ return self.local_copy().denominator(*args)
+
+ def imag(self,*args):
+ return self.local_copy().imag(*args)
+
+ def numerator(self,*args):
+ return self.local_copy().numerator(*args)
+
+ def real(self,*args):
+ return self.local_copy().real(*args)
+ pass
+
+class String(WrappedType):
+ def __init__(self,varPtr,isTemporaryVar=False):
+ WrappedType.__init__(self,varPtr,isTemporaryVar)
+ self._wrapped_type=int
+ pass
+
+ def __add__(self,*args):
+ return self.local_copy().__add__(*args)
+
+ def __iadd__(self,*args):
+ return self.local_copy().__add__(*args)
+
+ def __getitem__(self,*args):
+ return self.local_copy().__getitem__(*args)
+
+ def capitalize(self,*args):
+ return self.local_copy().capitalize(*args)
+
+ def center(self,*args):
+ return self.local_copy().center(*args)
+
+ def count(self,*args):
+ return self.local_copy().count(*args)
+
+ def decode(self,*args):
+ return self.local_copy().decode(*args)
+
+ def encode(self,*args):
+ return self.local_copy().encode(*args)
+
+ def endswith(self,*args):
+ return self.local_copy().endswith(*args)
+
+ def expandtabs(self,*args):
+ return self.local_copy().expandtabs(*args)
+
+ def find(self,*args):
+ return self.local_copy().find(*args)
+
+ def format(self,*args):
+ return self.local_copy().format(*args)
+
+ def index(self,*args):
+ return self.local_copy().index(*args)
+
+ def isalnum(self,*args):
+ return self.local_copy().isalnum(*args)
+
+ def isalpha(self,*args):
+ return self.local_copy().isalpha(*args)
+
+ def isdigit(self,*args):
+ return self.local_copy().isdigit(*args)
+
+ def islower(self,*args):
+ return self.local_copy().islower(*args)
+
+ def isspace(self,*args):
+ return self.local_copy().isspace(*args)
+
+ def istitle(self,*args):
+ return self.local_copy().istitle(*args)
+
+ def isupper(self,*args):
+ return self.local_copy().isupper(*args)
+
+ def join(self,*args):
+ return self.local_copy().join(*args)
+
+ def ljust(self,*args):
+ return self.local_copy().ljust(*args)
+
+ def lower(self,*args):
+ return self.local_copy().lower(*args)
+
+ def lstrip(self,*args):
+ return self.local_copy().lstrip(*args)
+
+ def partition(self,*args):
+ return self.local_copy().partition(*args)
+
+ def replace(self,*args):
+ return self.local_copy().replace(*args)
+
+ def rfind(self,*args):
+ return self.local_copy().rfind(*args)
+
+ def rindex(self,*args):
+ return self.local_copy().rindex(*args)
+
+ def rjust(self,*args):
+ return self.local_copy().rjust(*args)
+
+ def rpartition(self,*args):
+ return self.local_copy().rpartition(*args)
+
+ def rsplit(self,*args):
+ return self.local_copy().rsplit(*args)
+
+ def rstrip(self,*args):
+ return self.local_copy().rstrip(*args)
+
+ def split(self,*args):
+ return self.local_copy().split(*args)
+
+ def splitlines(self,*args):
+ return self.local_copy().splitlines(*args)
+
+ def startswith(self,*args):
+ return self.local_copy().startswith(*args)
+
+ def strip(self,*args):
+ return self.local_copy().strip(*args)
+
+ def swapcase(self,*args):
+ return self.local_copy().swapcase(*args)
+
+ def title(self,*args):
+ return self.local_copy().title(*args)
+
+ def translate(self,*args):
+ return self.local_copy().translate(*args)
+
+ def upper(self,*args):
+ return self.local_copy().upper(*args)
+
+ def zfill(self,*args):
+ return self.local_copy().zfill(*args)
+
+ def __len__(self):
+ return len(self.local_copy())
+ pass
+
+class Caller:
+ def __init__(self,varPtr,meth):
+ assert(isinstance(varPtr,SALOME._objref_PickelizedPyObjServer))
+ self._var_ptr=varPtr
+ self._meth=meth
+ pass
+
+ def __call__(self,*args):
+ ret=self._var_ptr.invokePythonMethodOn(self._meth,cPickle.dumps(args,cPickle.HIGHEST_PROTOCOL))
+ return GetHandlerFromRef(ret,True)
+ pass
+
+PyHandlerTypeMap={int:Int,float:Float,str:String,list:List,tuple:Tuple,dict:Dict}
+
+def GetHandlerFromRef(objCorba,isTempVar=False):
+ """ Returns a client that allows to handle a remote corba ref of a global var easily.
+ """
+ assert(isinstance(objCorba,SALOME._objref_PickelizedPyObjServer))
+ v=cPickle.loads(objCorba.fetchSerializedContent())
+ if v is None:
+ objCorba.UnRegister()
+ return None
+ return PyHandlerTypeMap[v.__class__](objCorba,isTempVar)
+
+
+def CreateRdOnlyGlobalVar(value,varName,scopeName):
+ import salome
+ dsm=salome.naming_service.Resolve("/DataServerManager")
+ d2s,isCreated=dsm.giveADataScopeCalled(scopeName)
+ return GetHandlerFromRef(d2s.createRdOnlyVar(varName,cPickle.dumps(value,cPickle.HIGHEST_PROTOCOL)),False)
+
+def CreateRdExtGlobalVar(value,varName,scopeName):
+ import salome
+ dsm=salome.naming_service.Resolve("/DataServerManager")
+ d2s,isCreated=dsm.giveADataScopeCalled(scopeName)
+ return GetHandlerFromRef(d2s.createRdExtVar(varName,cPickle.dumps(value,cPickle.HIGHEST_PROTOCOL)),False)
+
+def GetHandlerFromName(scopeName,varName):
+ import salome
+ dsm=salome.naming_service.Resolve("/DataServerManager")
+ d2s=dsm.retriveDataScope(scopeName)
+ return GetHandlerFromRef(d2s.retrieveVar(varName),False)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+#
+# 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
+#
+# Author : Anthony Geay
+
+import salome
+import SALOME
+import cPickle
+import gc
+import SalomeSDSClt
+
+st="jjj"
+dsm=salome.naming_service.Resolve("/DataServerManager")
+assert(dsm.isAliveAndKicking("Default"))
+assert(isinstance(dsm,SALOME._objref_DataServerManager))
+assert(isinstance(dsm.getDefaultScope(),SALOME._objref_DataScopeServer))
+d2s=dsm.createDataScope("tonyy")
+assert(isinstance(d2s,SALOME._objref_DataScopeServer))
+a=d2s.createRdWrVar("str","c")
+assert(a.getVarName()=="c")
+#
+a.setSerializedContent(cPickle.dumps(st,cPickle.HIGHEST_PROTOCOL))
+assert(cPickle.loads(a.fetchSerializedContent())==st)
+assert(cPickle.loads(a.fetchSerializedContent())==st)
+assert(cPickle.loads(d2s.retrieveVar("c").fetchSerializedContent())==st)
+assert(isinstance(d2s.retrieveVar("c"),SALOME._objref_PickelizedPyObjRdWrServer))
+assert(dsm.listScopes()==['Default','tonyy'])
+dsm.createDataScope("S2")
+assert(dsm.retriveDataScope("S2").getScopeName()=="S2")
+assert(dsm.listScopes()==['Default','tonyy','S2'])
+dsm.removeDataScope("Default")
+assert(dsm.listScopes()==['tonyy','S2'])
+dsm.removeDataScope("tonyy")
+assert(dsm.listScopes()==['S2'])
+a=dsm.retriveDataScope("S2").createRdWrVar("int","a")
+#
+sname="S7"
+dsm=salome.naming_service.Resolve("/DataServerManager")
+st=cPickle.dumps([],cPickle.HIGHEST_PROTOCOL)
+a=dsm.giveADataScopeCalled(sname)[0].createRdWrVar("list","a")
+dsm.giveADataScopeCalled(sname)
+a.setSerializedContent(cPickle.dumps([0,],cPickle.HIGHEST_PROTOCOL))
+assert(cPickle.loads(a.fetchSerializedContent())==[0,])
+a.setSerializedContent(st)
+assert(cPickle.loads(a.fetchSerializedContent())==[])
+tmp=a.invokePythonMethodOn("append",cPickle.dumps((0,),cPickle.HIGHEST_PROTOCOL))
+assert(cPickle.loads(a.fetchSerializedContent())==[0])
+for i in xrange(0,1000):
+ tmp=a.invokePythonMethodOn("append",cPickle.dumps((i,),cPickle.HIGHEST_PROTOCOL))
+ pass
+dsm.removeDataScope(sname)
+#
+sname="S4"
+d2s,_=dsm.giveADataScopeCalled(sname)
+d2s.createRdWrVar("list","a")
+a=SalomeSDSClt.GetHandlerFromRef(dsm.retriveDataScope(sname).retrieveVar("a"))
+a.append(1)
+for i in xrange(1000):
+ a.append(i)
+ pass
+assert(sum(a.local_copy())==499501)
+assert(dsm.isAliveAndKicking(sname))
+#
+dsm=salome.naming_service.Resolve("/DataServerManager")
+sname="S11"
+d2s,_=dsm.giveADataScopeCalled(sname)
+d2s.createRdWrVar("dict","a")
+a=SalomeSDSClt.GetHandlerFromName(sname,"a")
+assert(isinstance(a,SalomeSDSClt.Dict))
+a.assign({})
+a["ab"]=45 ; gc.collect(0)
+a["cd"]=[4,5] ; gc.collect(0)
+a["cd"].append(77) ; gc.collect(0)
+a["cd"].append([4,7,8]) ; gc.collect(0)
+a["cd"][3].append(3) ; gc.collect(0)
+a["ab"]+=2
+assert(a.local_copy()=={'ab':47,'cd':[4,5,77,[4,7,8,3]]})
+a["ab"]-=1
+assert(a.local_copy()=={'ab':46,'cd':[4,5,77,[4,7,8,3]]})
+assert(len(a)==2)
+c=a["cd"] ; gc.collect(0)
+assert(isinstance(c,SalomeSDSClt.List))
+a["cd"]=26 ; gc.collect(0)
+assert(a.local_copy()=={'ab':46,'cd':26})
+a["cd"]=c
+assert(a.local_copy()=={'ab':46,'cd':[4,5,77,[4,7,8,3]]})
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+#
+# 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
+#
+# Author : Anthony Geay
+
+import SalomeSDSClt
+import SALOME
+import salome
+import unittest
+import gc
+
+class SalomeSDS2Test(unittest.TestCase):
+
+ def testList1(self):
+ a=SalomeSDSClt.CreateRdExtGlobalVar([],"a","Scope0")
+ self.assertEqual(a.local_copy(),[])
+ a.append(5)
+ self.assertEqual(a.local_copy(),[5])
+ self.assertRaises(SALOME.SALOME_Exception,a.__delitem__,0)
+ a.append(["rt"])
+ self.assertEqual(a.local_copy(),[5,["rt"]])
+ a[1].append(8)
+ self.assertEqual(a.local_copy(),[5,["rt",8]])
+ a.extend(a)
+ self.assertEqual(a.local_copy(),[5,["rt",8],5,["rt",8]])
+ a.extend(a[3:])
+ self.assertEqual(a.local_copy(),[5,["rt",8],5,["rt",8],["rt",8]])
+ a[4].append(7)
+ self.assertEqual(a.local_copy(),[5,["rt",8],5,["rt",8],["rt",8,7]])
+ a._var_ptr.getMyDataScopeServer().deleteVar("a")
+ pass
+
+ def testDict1(self):
+ a=SalomeSDSClt.CreateRdExtGlobalVar({},"a","Scope0")
+ a["ab"]=4
+ self.assertEqual(a.local_copy(),{"ab":4})
+ a["cd"]=[5]
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5]})
+ a["cd"].append(77)
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5,77]})
+ a.__setitem__("ef",["a","bb"])
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5,77],"ef":["a","bb"]})
+ self.assertRaises(SALOME.SALOME_Exception,a.__setitem__,"ef",["a","bb"])
+ self.assertRaises(SALOME.SALOME_Exception,a.__setitem__,"ef",["a","bb","ccc"])
+ a["ef"].append("ccc")
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5,77],"ef":["a","bb","ccc"]})
+ a["gh"]=a
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5,77],"ef":["a","bb","ccc"],"gh":{"ab":4,"cd":[5,77],"ef":["a","bb","ccc"]}})
+ a["gh"]["cd"].append(99) ; a["cd"].append(88)
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5,77,88],"ef":["a","bb","ccc"],"gh":{"ab":4,"cd":[5,77,99],"ef":["a","bb","ccc"]}})
+ a._var_ptr.getMyDataScopeServer().deleteVar("a")
+ pass
+
+ def testReadOnly1(self):
+ a=SalomeSDSClt.CreateRdOnlyGlobalVar({"ab":4,"cd":[5,77]},"a","Scope0")
+ self.assertEqual(a.local_copy(),{"ab":4,"cd":[5,77]})
+ self.assertRaises(AttributeError,a.__getitem__,"ab")
+ a._var_ptr.getMyDataScopeServer().deleteVar("a")
+
+ def setUp(self):
+ salome.salome_init()
+ pass
+
+ pass
+
+unittest.main()
+
