Fix for bugs 11276, 11387: protect 'local' branches of 'client' classes with SALOMEDS...

diff --git a/src/SALOMEDS/SALOMEDS_AttributeComment.cxx b/src/SALOMEDS/SALOMEDS_AttributeComment.cxx
index 0d936c740b05e3808c5d8e0650ea73d472185292..3a54f00bb0843b05be0c092b685dec6115355f15 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeComment.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeComment.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeComment.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,15 +42,21 @@ SALOMEDS_AttributeComment::~SALOMEDS_AttributeComment()
 std::string SALOMEDS_AttributeComment::Value()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeComment)::DownCast(_local_impl)->Value()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeComment)::
+                                     DownCast(_local_impl)->Value()).ToCString();
+  }
   else aValue = SALOMEDS::AttributeComment::_narrow(_corba_impl)->Value();
   return aValue;
 }
  
 void SALOMEDS_AttributeComment::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeComment)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeComment)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  }
   else SALOMEDS::AttributeComment::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeDrawable.cxx b/src/SALOMEDS/SALOMEDS_AttributeDrawable.cxx
index ac1abc62b22e43e43dab0b53a69baad714190268..10d9c4df8866edc1ac7a3248a24800c5da07f103 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeDrawable.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeDrawable.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeDrawable.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,14 +41,20 @@ SALOMEDS_AttributeDrawable::~SALOMEDS_AttributeDrawable()
 bool SALOMEDS_AttributeDrawable::IsDrawable()
 {
   bool aValue;
-  if(_isLocal) aValue = (bool)Handle(SALOMEDSImpl_AttributeDrawable)::DownCast(_local_impl)->IsDrawable();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = (bool)Handle(SALOMEDSImpl_AttributeDrawable)::DownCast(_local_impl)->IsDrawable();
+  }
   else aValue = SALOMEDS::AttributeDrawable::_narrow(_corba_impl)->IsDrawable();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeDrawable::SetDrawable(bool value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeDrawable)::DownCast(_local_impl)->SetDrawable((int)value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeDrawable)::DownCast(_local_impl)->SetDrawable((int)value);
+  }
   else SALOMEDS::AttributeDrawable::_narrow(_corba_impl)->SetDrawable(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeDrawable_i.cxx b/src/SALOMEDS/SALOMEDS_AttributeDrawable_i.cxx
index 828b8add8322195fe31d9bbf4bac4febab614f53..e74b2221f25a68a360229d2c4f6ad0f81b68e450 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeDrawable_i.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeDrawable_i.cxx
@@ -28,16 +28,15 @@
 
 using namespace std;
 
-CORBA::Boolean SALOMEDS_AttributeDrawable_i::IsDrawable() 
+CORBA::Boolean SALOMEDS_AttributeDrawable_i::IsDrawable()
 {
   SALOMEDS::Locker lock;
   return (Handle(SALOMEDSImpl_AttributeDrawable)::DownCast(_impl)->IsDrawable() == 1);
 }
-                                                           
-void SALOMEDS_AttributeDrawable_i::SetDrawable(CORBA::Boolean value) 
+
+void SALOMEDS_AttributeDrawable_i::SetDrawable(CORBA::Boolean value)
 {
   SALOMEDS::Locker lock;
   CheckLocked();
   Handle(SALOMEDSImpl_AttributeDrawable)::DownCast(_impl)->SetDrawable(value);
 }
-

diff --git a/src/SALOMEDS/SALOMEDS_AttributeExpandable.cxx b/src/SALOMEDS/SALOMEDS_AttributeExpandable.cxx
index 4dce5430387bf6eeb4db8f83b12d74165ca823fc..4f14f10b4b864dc16e8c3e701da0a6d08b3c0623 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeExpandable.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeExpandable.cxx
@@ -22,11 +22,13 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeExpandable.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
 
-SALOMEDS_AttributeExpandable::SALOMEDS_AttributeExpandable(const Handle(SALOMEDSImpl_AttributeExpandable)& theAttr)
+SALOMEDS_AttributeExpandable::SALOMEDS_AttributeExpandable
+                  (const Handle(SALOMEDSImpl_AttributeExpandable)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -40,14 +42,20 @@ SALOMEDS_AttributeExpandable::~SALOMEDS_AttributeExpandable()
 bool SALOMEDS_AttributeExpandable::IsExpandable()
 {
   bool aValue;
-  if(_isLocal) aValue = (bool)Handle(SALOMEDSImpl_AttributeExpandable)::DownCast(_local_impl)->IsExpandable();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = (bool)Handle(SALOMEDSImpl_AttributeExpandable)::DownCast(_local_impl)->IsExpandable();
+  }
   else aValue = SALOMEDS::AttributeExpandable::_narrow(_corba_impl)->IsExpandable();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeExpandable::SetExpandable(bool value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeExpandable)::DownCast(_local_impl)->SetExpandable((int)value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeExpandable)::DownCast(_local_impl)->SetExpandable((int)value);
+  }
   else SALOMEDS::AttributeExpandable::_narrow(_corba_impl)->SetExpandable(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeExpandable_i.cxx b/src/SALOMEDS/SALOMEDS_AttributeExpandable_i.cxx
index 257ab67a7aee0dfee583addc109694ffa0d73faa..e62b60c8ca3b7833ff0ddc7f33def89c2f7a41d2 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeExpandable_i.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeExpandable_i.cxx
@@ -27,16 +27,15 @@
 
 using namespace std;
 
-CORBA::Boolean SALOMEDS_AttributeExpandable_i::IsExpandable() 
+CORBA::Boolean SALOMEDS_AttributeExpandable_i::IsExpandable()
 {
   SALOMEDS::Locker lock;
   return (Handle(SALOMEDSImpl_AttributeExpandable)::DownCast(_impl)->IsExpandable() == 1);
 }
-                                                           
-void SALOMEDS_AttributeExpandable_i::SetExpandable(CORBA::Boolean value) 
+
+void SALOMEDS_AttributeExpandable_i::SetExpandable(CORBA::Boolean value)
 {
   SALOMEDS::Locker lock;
   CheckLocked();
   Handle(SALOMEDSImpl_AttributeExpandable)::DownCast(_impl)->SetExpandable(value);
 }
-

diff --git a/src/SALOMEDS/SALOMEDS_AttributeExternalFileDef.cxx b/src/SALOMEDS/SALOMEDS_AttributeExternalFileDef.cxx
index 2dc8a3c9cb2e42e324bfb43abbbcfb118ba2c10b..9ea935ffef0312fa0ded049ce5f1e9b9db6692d4 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeExternalFileDef.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeExternalFileDef.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeExternalFileDef.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,15 +42,21 @@ SALOMEDS_AttributeExternalFileDef::~SALOMEDS_AttributeExternalFileDef()
 std::string SALOMEDS_AttributeExternalFileDef::Value()
 {
   std::string aValue;
-  if(_isLocal) 
-   aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeExternalFileDef)::DownCast(_local_impl)->Value()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeExternalFileDef)::
+                                     DownCast(_local_impl)->Value()).ToCString();
+  }
   else aValue = SALOMEDS::AttributeExternalFileDef::_narrow(_corba_impl)->Value();
   return aValue;
 }
  
 void SALOMEDS_AttributeExternalFileDef::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeExternalFileDef)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeExternalFileDef)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  }
   else SALOMEDS::AttributeExternalFileDef::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeFileType.cxx b/src/SALOMEDS/SALOMEDS_AttributeFileType.cxx
index ed535426a0add697988f02df1165fe7fca78c8fc..797941a08829646ca54c13bc0dcb7c09c7dc0e74 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeFileType.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeFileType.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeFileType.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,15 +42,21 @@ SALOMEDS_AttributeFileType::~SALOMEDS_AttributeFileType()
 std::string SALOMEDS_AttributeFileType::Value()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeFileType)::DownCast(_local_impl)->Value()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeFileType)::
+                                     DownCast(_local_impl)->Value()).ToCString();
+  }
   else aValue = SALOMEDS::AttributeFileType::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeFileType::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeFileType)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeFileType)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  }
   else SALOMEDS::AttributeFileType::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeFlags.cxx b/src/SALOMEDS/SALOMEDS_AttributeFlags.cxx
index 5168f238b16dfe196c7ae98df77175c1e91cb35a..935a7edeee2ff471473083ac559b407d653e2e6f 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeFlags.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeFlags.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeFlags.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,14 +41,20 @@ SALOMEDS_AttributeFlags::~SALOMEDS_AttributeFlags()
 int SALOMEDS_AttributeFlags::GetFlags()
 {
   int aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeFlags)::DownCast(_local_impl)->Get();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = Handle(SALOMEDSImpl_AttributeFlags)::DownCast(_local_impl)->Get();
+  }
   else aValue = SALOMEDS::AttributeFlags::_narrow(_corba_impl)->GetFlags();
   return aValue;
 }
 
 void SALOMEDS_AttributeFlags::SetFlags(int theFlags)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeFlags)::DownCast(_local_impl)->Set(theFlags);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeFlags)::DownCast(_local_impl)->Set(theFlags);
+  }
   else SALOMEDS::AttributeFlags::_narrow(_corba_impl)->SetFlags(theFlags);
 }
 
@@ -58,12 +65,13 @@ bool SALOMEDS_AttributeFlags::Get(int theFlag)
  
 void SALOMEDS_AttributeFlags::Set(int theFlag, bool theValue)
 {
-  if(_isLocal)  {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeFlags) anAttr = Handle(SALOMEDSImpl_AttributeFlags)::DownCast(_local_impl);
-    if ( theValue )
-      anAttr->Set( anAttr->Get() | theFlag );
+    if (theValue)
+      anAttr->Set(anAttr->Get() | theFlag);
     else
-      anAttr->Set( anAttr->Get() & ~theFlag );    
+      anAttr->Set(anAttr->Get() & ~theFlag);    
   }
   else SALOMEDS::AttributeFlags::_narrow(_corba_impl)->Set(theFlag, theValue);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeGraphic.cxx b/src/SALOMEDS/SALOMEDS_AttributeGraphic.cxx
index e0dc038d9ed132ac21499c56894640d8d175b7fa..38b75427961fbd7323175facbf2198e3e8fd5729 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeGraphic.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeGraphic.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeGraphic.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -38,16 +39,22 @@ SALOMEDS_AttributeGraphic::~SALOMEDS_AttributeGraphic()
 {}
 
 
-bool SALOMEDS_AttributeGraphic:: GetVisibility(int theViewId)
+bool SALOMEDS_AttributeGraphic::GetVisibility(int theViewId)
 {
   bool aValue;
-  if(_isLocal) aValue = (bool)Handle(SALOMEDSImpl_AttributeGraphic)::DownCast(_local_impl)->GetVisibility(theViewId);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = (bool)Handle(SALOMEDSImpl_AttributeGraphic)::DownCast(_local_impl)->GetVisibility(theViewId);
+  }
   else aValue = SALOMEDS::AttributeGraphic::_narrow(_corba_impl)->GetVisibility(theViewId);
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeGraphic::SetVisibility(int theViewId, bool theValue)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeGraphic)::DownCast(_local_impl)->SetVisibility(theViewId, theValue);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeGraphic)::DownCast(_local_impl)->SetVisibility(theViewId, theValue);
+  }
   else SALOMEDS::AttributeGraphic::_narrow(_corba_impl)->SetVisibility(theViewId, theValue);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeIOR.cxx b/src/SALOMEDS/SALOMEDS_AttributeIOR.cxx
index de6ca253ff3c04d2c1c5827f611d223e18f8de19..04b37485abcafc75daa672f1377efeb486eba46e 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeIOR.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeIOR.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeIOR.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,15 +42,21 @@ SALOMEDS_AttributeIOR::~SALOMEDS_AttributeIOR()
 std::string SALOMEDS_AttributeIOR::Value()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeIOR)::DownCast(_local_impl)->Value()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeIOR)::
+                                     DownCast(_local_impl)->Value()).ToCString();
+  }
   else aValue = SALOMEDS::AttributeIOR::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeIOR::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeIOR)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeIOR)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  }
   else SALOMEDS::AttributeIOR::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeInteger.cxx b/src/SALOMEDS/SALOMEDS_AttributeInteger.cxx
index b32650bcdc5ffe0175268f0fbe48264d51edaedd..f7d4addfb5e9291a0ba35c966daa17443d28a11a 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeInteger.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeInteger.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeInteger.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,14 +41,20 @@ SALOMEDS_AttributeInteger::~SALOMEDS_AttributeInteger()
 int SALOMEDS_AttributeInteger::Value()
 {
   int aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeInteger)::DownCast(_local_impl)->Value();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aValue = Handle(SALOMEDSImpl_AttributeInteger)::DownCast(_local_impl)->Value();
+  }
   else aValue = SALOMEDS::AttributeInteger::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeInteger::SetValue(int value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeInteger)::DownCast(_local_impl)->SetValue(value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeInteger)::DownCast(_local_impl)->SetValue(value);
+  }
   else SALOMEDS::AttributeInteger::_narrow(_corba_impl)->SetValue(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeLocalID.cxx b/src/SALOMEDS/SALOMEDS_AttributeLocalID.cxx
index c9d778adb36a99e0efbfe9c788b5e279eb146cdf..379fc58b63312c653d774bcc3d8a7ecf275c260e 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeLocalID.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeLocalID.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeLocalID.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,14 +41,20 @@ SALOMEDS_AttributeLocalID::~SALOMEDS_AttributeLocalID()
 int SALOMEDS_AttributeLocalID::Value()
 {
   int aValue;
-  if(_isLocal) aValue = (bool)Handle(SALOMEDSImpl_AttributeLocalID)::DownCast(_local_impl)->Value();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = (bool)Handle(SALOMEDSImpl_AttributeLocalID)::DownCast(_local_impl)->Value();
+  }
   else aValue = SALOMEDS::AttributeLocalID::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeLocalID::SetValue(int value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeLocalID)::DownCast(_local_impl)->SetValue(value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeLocalID)::DownCast(_local_impl)->SetValue(value);
+  }
   else SALOMEDS::AttributeLocalID::_narrow(_corba_impl)->SetValue(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeName.cxx b/src/SALOMEDS/SALOMEDS_AttributeName.cxx
index b4b8d7b18b61e28e927b1af7d8f9f570a5a7cadc..1fc1a1a8a2b3e36d1bc0472b67a40cea623fdc95 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeName.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeName.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeName.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,15 +42,21 @@ SALOMEDS_AttributeName::~SALOMEDS_AttributeName()
 std::string SALOMEDS_AttributeName::Value()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeName)::DownCast(_local_impl)->Value()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeName)::
+                                     DownCast(_local_impl)->Value()).ToCString();
+  }
   else aValue = SALOMEDS::AttributeName::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeName::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeName)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeName)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  }
   else SALOMEDS::AttributeName::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeOpened.cxx b/src/SALOMEDS/SALOMEDS_AttributeOpened.cxx
index 7424a749871e9f38a93b890c6acc8ee69637ee12..a2c82dd8116ce67af36c5b36ae6ff9f6fa251ba7 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeOpened.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeOpened.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeOpened.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,13 +41,19 @@ SALOMEDS_AttributeOpened::~SALOMEDS_AttributeOpened()
 bool SALOMEDS_AttributeOpened::IsOpened()
 {
   bool aValue;
-  if(_isLocal) aValue = (bool)Handle(SALOMEDSImpl_AttributeOpened)::DownCast(_local_impl)->IsOpened();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aValue = (bool)Handle(SALOMEDSImpl_AttributeOpened)::DownCast(_local_impl)->IsOpened();
+  }
   else aValue = SALOMEDS::AttributeOpened::_narrow(_corba_impl)->IsOpened();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeOpened::SetOpened(bool value)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeOpened)::DownCast(_local_impl)->SetOpened((int)value);
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeOpened)::DownCast(_local_impl)->SetOpened((int)value);
+  }
   else SALOMEDS::AttributeOpened::_narrow(_corba_impl)->SetOpened(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributePersistentRef.cxx b/src/SALOMEDS/SALOMEDS_AttributePersistentRef.cxx
index 1ca0bf276186a30d34f05e60ddfc7a112f1329fb..276cafe29e30d6e5588dfbe28d980b897c48c750 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributePersistentRef.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributePersistentRef.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributePersistentRef.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,15 +42,21 @@ SALOMEDS_AttributePersistentRef::~SALOMEDS_AttributePersistentRef()
 std::string SALOMEDS_AttributePersistentRef::Value()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePersistentRef)::DownCast(_local_impl)->Value()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePersistentRef)::
+                                     DownCast(_local_impl)->Value()).ToCString();
+  }
   else aValue = SALOMEDS::AttributePersistentRef::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributePersistentRef::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributePersistentRef)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributePersistentRef)::DownCast(_local_impl)->SetValue((char*)value.c_str());
+  }
   else SALOMEDS::AttributePersistentRef::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributePixMap.cxx b/src/SALOMEDS/SALOMEDS_AttributePixMap.cxx
index 21bf8a4892a0478d5c4cbddf84436ea9aecf606a..d82db803f53a03695b60f9305e5dc88552ee1fea 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributePixMap.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributePixMap.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributePixMap.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,7 +42,10 @@ SALOMEDS_AttributePixMap::~SALOMEDS_AttributePixMap()
 bool SALOMEDS_AttributePixMap::HasPixMap()
 {
   bool ret;
-  if(_isLocal) ret = Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_local_impl)->HasPixMap();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_local_impl)->HasPixMap();
+  }
   else ret = SALOMEDS::AttributePixMap::_narrow(_corba_impl)->HasPixMap();
   return ret;
 }
@@ -49,15 +53,21 @@ bool SALOMEDS_AttributePixMap::HasPixMap()
 std::string SALOMEDS_AttributePixMap::GetPixMap()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_local_impl)->GetPixMap()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePixMap)::
+                                     DownCast(_local_impl)->GetPixMap()).ToCString();
+  }
   else aValue = SALOMEDS::AttributePixMap::_narrow(_corba_impl)->GetPixMap();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributePixMap::SetPixMap(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_local_impl)->SetPixMap((char*)value.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_local_impl)->SetPixMap((char*)value.c_str());
+  }
   else SALOMEDS::AttributePixMap::_narrow(_corba_impl)->SetPixMap(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributePixMap_i.cxx b/src/SALOMEDS/SALOMEDS_AttributePixMap_i.cxx
index 0c01c6e50ecac456a19ce4747f6a39a39898fc69..8ba8c973b384ae814694cedd0a6edb206f863b44 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributePixMap_i.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributePixMap_i.cxx
@@ -24,28 +24,30 @@
 
 #include "SALOMEDS_AttributePixMap_i.hxx"
 #include "SALOMEDS.hxx"
+
 #include <TCollection_AsciiString.hxx>
 
 using namespace std;
 
-CORBA::Boolean SALOMEDS_AttributePixMap_i::HasPixMap() 
+CORBA::Boolean SALOMEDS_AttributePixMap_i::HasPixMap()
 {
+  SALOMEDS::Locker lock;
   return Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_impl)->HasPixMap();
 }
 
-char* SALOMEDS_AttributePixMap_i::GetPixMap() 
+char* SALOMEDS_AttributePixMap_i::GetPixMap()
 {
   SALOMEDS::Locker lock;
-  CORBA::String_var S = 
-    CORBA::string_dup(TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_impl)->GetPixMap()).ToCString());
+  CORBA::String_var S =
+    CORBA::string_dup(TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePixMap)::
+                                              DownCast(_impl)->GetPixMap()).ToCString());
   return S._retn();
 }
 
-void SALOMEDS_AttributePixMap_i::SetPixMap(const char* value) 
+void SALOMEDS_AttributePixMap_i::SetPixMap(const char* value)
 {
   SALOMEDS::Locker lock;
   CheckLocked();
   CORBA::String_var Str = CORBA::string_dup(value);
   Handle(SALOMEDSImpl_AttributePixMap)::DownCast(_impl)->SetPixMap(TCollection_ExtendedString(Str));
 }
-

diff --git a/src/SALOMEDS/SALOMEDS_AttributePythonObject.cxx b/src/SALOMEDS/SALOMEDS_AttributePythonObject.cxx
index 71990e4db97ca5287ac73ee138ea2d6a2a37e0fa..789dd361812f4d1c2667e976b697adafa68a956c 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributePythonObject.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributePythonObject.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributePythonObject.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -41,7 +42,10 @@ SALOMEDS_AttributePythonObject::~SALOMEDS_AttributePythonObject()
 bool SALOMEDS_AttributePythonObject::IsScript()
 {
   bool ret;
-  if(_isLocal) ret = Handle(SALOMEDSImpl_AttributePythonObject)::DownCast(_local_impl)->IsScript();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = Handle(SALOMEDSImpl_AttributePythonObject)::DownCast(_local_impl)->IsScript();
+  }
   else ret = SALOMEDS::AttributePythonObject::_narrow(_corba_impl)->IsScript();
   return ret;
 }
@@ -49,15 +53,22 @@ bool SALOMEDS_AttributePythonObject::IsScript()
 std::string SALOMEDS_AttributePythonObject::GetObject()
 {
   std::string aValue;
-  if(_isLocal) 
-    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePythonObject)::DownCast(_local_impl)->GetObject()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributePythonObject)::
+                                     DownCast(_local_impl)->GetObject()).ToCString();
+  }
   else aValue = SALOMEDS::AttributePythonObject::_narrow(_corba_impl)->GetObject();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributePythonObject::SetObject(const std::string& theSequence, bool IsScript)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributePythonObject)::DownCast(_local_impl)->SetObject((char*)theSequence.c_str(), IsScript);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributePythonObject)::
+      DownCast(_local_impl)->SetObject((char*)theSequence.c_str(), IsScript);
+  }
   else SALOMEDS::AttributePythonObject::_narrow(_corba_impl)->SetObject(theSequence.c_str(), IsScript);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeReal.cxx b/src/SALOMEDS/SALOMEDS_AttributeReal.cxx
index 8d98f6cf120ed2d4fec1d7fe74db63f8e57f8418..e96837534101e2b4bc81915bae99ccd9db1146e6 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeReal.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeReal.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeReal.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,14 +41,20 @@ SALOMEDS_AttributeReal::~SALOMEDS_AttributeReal()
 double SALOMEDS_AttributeReal::Value()
 {
   double aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeReal)::DownCast(_local_impl)->Value();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = Handle(SALOMEDSImpl_AttributeReal)::DownCast(_local_impl)->Value();
+  }
   else aValue = SALOMEDS::AttributeReal::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeReal::SetValue(double value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeReal)::DownCast(_local_impl)->SetValue(value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeReal)::DownCast(_local_impl)->SetValue(value);
+  }
   else SALOMEDS::AttributeReal::_narrow(_corba_impl)->SetValue(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeSelectable.cxx b/src/SALOMEDS/SALOMEDS_AttributeSelectable.cxx
index 6ffb270f7fd32e33a0ae84d336436dfe6ed75d2c..fb16c9907c38299b727ba343d499a76c1aa3da07 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeSelectable.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeSelectable.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeSelectable.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -40,13 +41,19 @@ SALOMEDS_AttributeSelectable::~SALOMEDS_AttributeSelectable()
 bool SALOMEDS_AttributeSelectable::IsSelectable()
 {
   bool aValue;
-  if(_isLocal) aValue = (bool)Handle(SALOMEDSImpl_AttributeSelectable)::DownCast(_local_impl)->IsSelectable();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = (bool)Handle(SALOMEDSImpl_AttributeSelectable)::DownCast(_local_impl)->IsSelectable();
+  }
   else aValue = SALOMEDS::AttributeSelectable::_narrow(_corba_impl)->IsSelectable();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeSelectable::SetSelectable(bool value)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSelectable)::DownCast(_local_impl)->SetSelectable((int)value);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeSelectable)::DownCast(_local_impl)->SetSelectable((int)value);
+  }
   else SALOMEDS::AttributeSelectable::_narrow(_corba_impl)->SetSelectable(value);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeSequenceOfInteger.cxx b/src/SALOMEDS/SALOMEDS_AttributeSequenceOfInteger.cxx
index fac549e3be2c4b9c97d01c67683e91b59c6e331c..a2d8613122d31ff5182a3b32f4415e06d41fb4ee 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeSequenceOfInteger.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeSequenceOfInteger.cxx
@@ -22,17 +22,19 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeSequenceOfInteger.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
 #include <TColStd_HSequenceOfInteger.hxx>
 
-SALOMEDS_AttributeSequenceOfInteger
-::SALOMEDS_AttributeSequenceOfInteger(const Handle(SALOMEDSImpl_AttributeSequenceOfInteger)& theAttr)
+SALOMEDS_AttributeSequenceOfInteger::SALOMEDS_AttributeSequenceOfInteger
+                  (const Handle(SALOMEDSImpl_AttributeSequenceOfInteger)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
-SALOMEDS_AttributeSequenceOfInteger::SALOMEDS_AttributeSequenceOfInteger(SALOMEDS::AttributeSequenceOfInteger_ptr theAttr)
+SALOMEDS_AttributeSequenceOfInteger::SALOMEDS_AttributeSequenceOfInteger
+                  (SALOMEDS::AttributeSequenceOfInteger_ptr theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -42,15 +44,17 @@ SALOMEDS_AttributeSequenceOfInteger::~SALOMEDS_AttributeSequenceOfInteger()
 void SALOMEDS_AttributeSequenceOfInteger::Assign(const std::vector<int>& other)
 {
   int i, aLength = other.size();
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger;
-    for(i = 0; i < aLength; i++) aSeq->Append(other[i]);
+    for (i = 0; i < aLength; i++) aSeq->Append(other[i]);
     Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Assign(aSeq);
   }
   else {
     SALOMEDS::LongSeq_var aSeq = new SALOMEDS::LongSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = other[i];
+    for (i = 0; i < aLength; i++) aSeq[i] = other[i];
     SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl)->Assign(aSeq);
   }
 }
@@ -59,50 +63,70 @@ std::vector<int> SALOMEDS_AttributeSequenceOfInteger::CorbaSequence()
 {
   std::vector<int> aVector;
   int i, aLength;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeSequenceOfInteger) aSeqAttr;
     aSeqAttr = Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl);
     aLength = aSeqAttr->Length();
-    for(i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
+    for (i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
   }
   else {
-    SALOMEDS::AttributeSequenceOfInteger_var aSeqAttr = SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl);
+    SALOMEDS::AttributeSequenceOfInteger_var aSeqAttr =
+      SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl);
     aLength = aSeqAttr->Length();
-    for(i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
+    for (i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
   }
   return aVector;
 }
- 
+
 void SALOMEDS_AttributeSequenceOfInteger::Add(int value)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Add(value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Add(value);
+  }
   else SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl)->Add(value);
 }
 
 void SALOMEDS_AttributeSequenceOfInteger::Remove(int index)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Remove(index);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Remove(index);
+  }
   else SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl)->Remove(index);
 }
- 
+
 void SALOMEDS_AttributeSequenceOfInteger::ChangeValue(int index, int value)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->ChangeValue(index, value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->ChangeValue(index, value);
+  }
   else SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl)->ChangeValue(index, value);
 }
- 
+
 int SALOMEDS_AttributeSequenceOfInteger::Value(int index)
 {
   int aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Value(index);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)->Value(index);
+  }
   else aValue = SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl)->Value(index);
   return aValue;
 }
- 
+
 int SALOMEDS_AttributeSequenceOfInteger::Length()
 {
   int aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)-> Length();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = Handle(SALOMEDSImpl_AttributeSequenceOfInteger)::DownCast(_local_impl)-> Length();
+  }
   else aValue = SALOMEDS::AttributeSequenceOfInteger::_narrow(_corba_impl)-> Length();
   return aValue;
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeSequenceOfReal.cxx b/src/SALOMEDS/SALOMEDS_AttributeSequenceOfReal.cxx
index faffcaa29b3f67c0605b75774fd20f3464cf8c91..9697594f8c49e0c9314d6febace9fd4becec004f 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeSequenceOfReal.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeSequenceOfReal.cxx
@@ -22,17 +22,19 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeSequenceOfReal.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
 #include <TColStd_HSequenceOfReal.hxx>
 
-SALOMEDS_AttributeSequenceOfReal
-::SALOMEDS_AttributeSequenceOfReal(const Handle(SALOMEDSImpl_AttributeSequenceOfReal)& theAttr)
+SALOMEDS_AttributeSequenceOfReal::SALOMEDS_AttributeSequenceOfReal
+                  (const Handle(SALOMEDSImpl_AttributeSequenceOfReal)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
-SALOMEDS_AttributeSequenceOfReal::SALOMEDS_AttributeSequenceOfReal(SALOMEDS::AttributeSequenceOfReal_ptr theAttr)
+SALOMEDS_AttributeSequenceOfReal::SALOMEDS_AttributeSequenceOfReal
+                  (SALOMEDS::AttributeSequenceOfReal_ptr theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -42,15 +44,17 @@ SALOMEDS_AttributeSequenceOfReal::~SALOMEDS_AttributeSequenceOfReal()
 void SALOMEDS_AttributeSequenceOfReal::Assign(const std::vector<double>& other)
 {
   int i, aLength = other.size();
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfReal) aSeq = new TColStd_HSequenceOfReal;
-    for(i = 0; i < aLength; i++) aSeq->Append(other[i]);
+    for (i = 0; i < aLength; i++) aSeq->Append(other[i]);
     Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Assign(aSeq);
   }
   else {
     SALOMEDS::DoubleSeq_var aSeq = new SALOMEDS::DoubleSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = other[i];
+    for (i = 0; i < aLength; i++) aSeq[i] = other[i];
     SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl)->Assign(aSeq);
   }
 }
@@ -59,50 +63,69 @@ std::vector<double> SALOMEDS_AttributeSequenceOfReal::CorbaSequence()
 {
   std::vector<double> aVector;
   int i, aLength;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(SALOMEDSImpl_AttributeSequenceOfReal) aSeqAttr;
     aSeqAttr = Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl);
     aLength = aSeqAttr->Length();
-    for(i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
+    for (i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
   }
   else {
     SALOMEDS::AttributeSequenceOfReal_var aSeqAttr = SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl);
     aLength = aSeqAttr->Length();
-    for(i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
+    for (i = 1; i <=aLength; i++) aVector.push_back(aSeqAttr->Value(i));
   }
   return aVector;
 }
- 
+
 void SALOMEDS_AttributeSequenceOfReal::Add(double value)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Add(value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Add(value);
+  }
   else SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl)->Add(value);
 }
 
 void SALOMEDS_AttributeSequenceOfReal::Remove(int index)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Remove(index);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Remove(index);
+  }
   else SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl)->Remove(index);
 }
- 
+
 void SALOMEDS_AttributeSequenceOfReal::ChangeValue(int index, double value)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->ChangeValue(index, value);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->ChangeValue(index, value);
+  }
   else SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl)->ChangeValue(index, value);
 }
- 
+
 double SALOMEDS_AttributeSequenceOfReal::Value(int index)
 {
   double aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Value(index);
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aValue = Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)->Value(index);
+  }
   else aValue = SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl)->Value(index);
   return aValue;
 }
- 
+
 int SALOMEDS_AttributeSequenceOfReal::Length()
 {
   int aValue;
-  if(_isLocal) aValue = Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)-> Length();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aValue = Handle(SALOMEDSImpl_AttributeSequenceOfReal)::DownCast(_local_impl)-> Length();
+  }
   else aValue = SALOMEDS::AttributeSequenceOfReal::_narrow(_corba_impl)-> Length();
   return aValue;
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeStudyProperties.cxx b/src/SALOMEDS/SALOMEDS_AttributeStudyProperties.cxx
index 8447a28dd4c3ef61f9a0f2592c9f763cf750cbb9..b56a728b1176a4c0552fc7dbba9b9ea8c7c97245 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeStudyProperties.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeStudyProperties.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeStudyProperties.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx>
@@ -46,6 +47,8 @@ SALOMEDS_AttributeStudyProperties::~SALOMEDS_AttributeStudyProperties()
 void SALOMEDS_AttributeStudyProperties::SetUserName(const std::string& theName)
 {
   if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeStudyProperties) anImpl =
       Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl);
     anImpl->ChangeCreatorName((char*)theName.c_str());
@@ -57,6 +60,7 @@ std::string SALOMEDS_AttributeStudyProperties::GetUserName()
 {
   std::string aName;
   if (_isLocal) {
+    SALOMEDS::Locker lock;
     TCollection_ExtendedString S =
       Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->GetCreatorName();
     aName = TCollection_AsciiString(S).ToCString();
@@ -73,6 +77,8 @@ void SALOMEDS_AttributeStudyProperties::SetCreationDate
               (int theMinute, int theHour, int theDay, int theMonth, int theYear)
 {
   if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeStudyProperties) anImpl =
       Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl);
     int aTmp;
@@ -96,6 +102,7 @@ bool SALOMEDS_AttributeStudyProperties::GetCreationDate(int& theMinute,
 {
   bool ret;
   if (_isLocal) {
+    SALOMEDS::Locker lock;
     ret = Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast
       (_local_impl)->GetCreationDate(theMinute, theHour, theDay, theMonth, theYear);
   } else {
@@ -117,6 +124,8 @@ bool SALOMEDS_AttributeStudyProperties::GetCreationDate(int& theMinute,
 void SALOMEDS_AttributeStudyProperties::SetCreationMode(const std::string& theMode)
 {
   if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     if (theMode == "from scratch")
       Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->SetCreationMode(1);
     else if (theMode == "copy from")
@@ -131,6 +140,7 @@ std::string SALOMEDS_AttributeStudyProperties::GetCreationMode()
 {
   std::string aMode;
   if (_isLocal) {
+    SALOMEDS::Locker lock;
     int mode  = Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->GetCreationMode();
     if (mode == 1) aMode = "from scratch";
     if (mode == 2) aMode = "copy from";
@@ -142,8 +152,10 @@ std::string SALOMEDS_AttributeStudyProperties::GetCreationMode()
 
 void SALOMEDS_AttributeStudyProperties::SetModified(int theModified)
 {
-  if (_isLocal)
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->SetModified(theModified);
+  }
   else
     SALOMEDS::AttributeStudyProperties::_narrow(_corba_impl)->SetModified(theModified);
 }
@@ -151,8 +163,10 @@ void SALOMEDS_AttributeStudyProperties::SetModified(int theModified)
 bool SALOMEDS_AttributeStudyProperties::IsModified()
 {
   bool ret;
-  if (_isLocal)
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     ret = Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->IsModified();
+  }
   else
     ret = SALOMEDS::AttributeStudyProperties::_narrow(_corba_impl)->IsModified();
   return ret;
@@ -161,8 +175,10 @@ bool SALOMEDS_AttributeStudyProperties::IsModified()
 int SALOMEDS_AttributeStudyProperties::GetModified()
 {
   int isModified;
-  if (_isLocal)
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     isModified = Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->GetModified();
+  }
   else
     isModified = SALOMEDS::AttributeStudyProperties::_narrow(_corba_impl)->GetModified();
   return isModified;
@@ -170,8 +186,10 @@ int SALOMEDS_AttributeStudyProperties::GetModified()
 
 void SALOMEDS_AttributeStudyProperties::SetLocked(bool theLocked)
 {
-  if (_isLocal)
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->SetLocked(theLocked);
+  }
   else
     SALOMEDS::AttributeStudyProperties::_narrow(_corba_impl)->SetLocked(theLocked);
 }
@@ -179,8 +197,10 @@ void SALOMEDS_AttributeStudyProperties::SetLocked(bool theLocked)
 bool SALOMEDS_AttributeStudyProperties::IsLocked()
 {
   bool ret;
-  if (_isLocal)
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     ret = Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl)->IsLocked();
+  }
   else
     ret = SALOMEDS::AttributeStudyProperties::_narrow(_corba_impl)->IsLocked();
   return ret;
@@ -194,6 +214,8 @@ void SALOMEDS_AttributeStudyProperties::SetModification(const std::string& theNa
                                                        int theYear)
 {
   if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeStudyProperties) anImpl =
       Handle(SALOMEDSImpl_AttributeStudyProperties)::DownCast(_local_impl);
     anImpl->SetModification((char*)theName.c_str(), theMinute, theHour, theDay, theMonth, theYear);
@@ -217,6 +239,7 @@ void SALOMEDS_AttributeStudyProperties::GetModificationsList(std::vector<std::st
   int i, aLength;
 
   if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aNames;
     Handle(TColStd_HSequenceOfInteger) aMinutes, aHours, aDays, aMonths, aYears;
     Handle(SALOMEDSImpl_AttributeStudyProperties) anImpl =

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx b/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx
index d25dd7854b50df3977e79c2b11d612c118dd59f4..4d8bb55464cebb0028226952e330dd135c3afab1 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTableOfInteger.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -29,12 +30,13 @@
 #include <TColStd_HSequenceOfExtendedString.hxx>
 
 
-SALOMEDS_AttributeTableOfInteger
-::SALOMEDS_AttributeTableOfInteger(const Handle(SALOMEDSImpl_AttributeTableOfInteger)& theAttr)
+SALOMEDS_AttributeTableOfInteger::SALOMEDS_AttributeTableOfInteger
+                  (const Handle(SALOMEDSImpl_AttributeTableOfInteger)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
-SALOMEDS_AttributeTableOfInteger::SALOMEDS_AttributeTableOfInteger(SALOMEDS::AttributeTableOfInteger_ptr theAttr)
+SALOMEDS_AttributeTableOfInteger::SALOMEDS_AttributeTableOfInteger
+                  (SALOMEDS::AttributeTableOfInteger_ptr theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -44,35 +46,45 @@ SALOMEDS_AttributeTableOfInteger::~SALOMEDS_AttributeTableOfInteger()
 
 void SALOMEDS_AttributeTableOfInteger::SetTitle(const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetTitle(theTitle.c_str());
 }
 
 std::string SALOMEDS_AttributeTableOfInteger::GetTitle()
 {
   std::string aStr;
-  if(_isLocal) 
-    aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetTitle()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfInteger)::
+                                   DownCast(_local_impl)->GetTitle()).ToCString();
+  }
   else aStr = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetTitle();
   return aStr;
 }
 
 void SALOMEDS_AttributeTableOfInteger::SetRowTitle(int theIndex, const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetRowTitle(theIndex, 
-                                                                                               (char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfInteger)::
+      DownCast(_local_impl)->SetRowTitle(theIndex, (char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRowTitle(theIndex, theTitle.c_str());
 }
 
 void SALOMEDS_AttributeTableOfInteger::SetRowTitles(const std::vector<std::string>& theTitles)
 {
-  CheckLocked();
   int aLength = theTitles.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetRowTitles(aSeq);
   }
   else {
@@ -88,7 +100,8 @@ std::vector<std::string> SALOMEDS_AttributeTableOfInteger::GetRowTitles()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetRowTitles();
     aLength = aSeq->Length();
@@ -104,26 +117,29 @@ std::vector<std::string> SALOMEDS_AttributeTableOfInteger::GetRowTitles()
 
 void SALOMEDS_AttributeTableOfInteger::SetColumnTitle(int theIndex, const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) 
-    Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetColumnTitle(theIndex, 
-                                                                                       (char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfInteger)::
+      DownCast(_local_impl)->SetColumnTitle(theIndex, (char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetColumnTitle(theIndex, theTitle.c_str());
 }
 
 void SALOMEDS_AttributeTableOfInteger::SetColumnTitles(const std::vector<std::string>& theTitles)
 {
-  CheckLocked();
   int aLength = theTitles.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetColumnTitles(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = theTitles[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = theTitles[i].c_str();
     SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetColumnTitles(aSeq);
   }
 }
@@ -132,41 +148,46 @@ std::vector<std::string> SALOMEDS_AttributeTableOfInteger::GetColumnTitles()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetColumnTitles();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetColumnTitles();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfInteger::SetRowUnit(int theIndex, const std::string& theUnit)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetRowUnit(theIndex, 
-                                                                                              (char*)theUnit.c_str()); 
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfInteger)::
+      DownCast(_local_impl)->SetRowUnit(theIndex, (char*)theUnit.c_str());
+  }
   else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRowUnit(theIndex, theUnit.c_str());
 }
 
 void SALOMEDS_AttributeTableOfInteger::SetRowUnits(const std::vector<std::string>& theUnits)
 {
-  CheckLocked();
   int aLength = theUnits.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theUnits[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theUnits[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetRowUnits(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theUnits[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theUnits[i].c_str();
     SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRowUnits(aSeq);
   }
 }
@@ -175,16 +196,17 @@ std::vector<std::string> SALOMEDS_AttributeTableOfInteger::GetRowUnits()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetRowUnits();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowUnits();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
@@ -192,7 +214,10 @@ std::vector<std::string> SALOMEDS_AttributeTableOfInteger::GetRowUnits()
 int SALOMEDS_AttributeTableOfInteger::GetNbRows()
 {
   int aNb;
-  if(_isLocal) aNb = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetNbRows();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aNb = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetNbRows();
+  }
   else aNb = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetNbRows();
   return aNb;
 }
@@ -200,7 +225,10 @@ int SALOMEDS_AttributeTableOfInteger::GetNbRows()
 int SALOMEDS_AttributeTableOfInteger::GetNbColumns()
 {  
   int aNb;
-  if(_isLocal) aNb = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetNbColumns();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aNb = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetNbColumns();
+  }
   else aNb = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetNbColumns();
   return aNb;
   
@@ -208,9 +236,10 @@ int SALOMEDS_AttributeTableOfInteger::GetNbColumns()
 
 void SALOMEDS_AttributeTableOfInteger::AddRow(const std::vector<int>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfInteger) aRow = new TColStd_HSequenceOfInteger;
@@ -232,9 +261,10 @@ void SALOMEDS_AttributeTableOfInteger::AddRow(const std::vector<int>& theData)
 
 void SALOMEDS_AttributeTableOfInteger::SetRow(int theRow, const std::vector<int>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfInteger) aRow = new TColStd_HSequenceOfInteger;
@@ -249,7 +279,7 @@ void SALOMEDS_AttributeTableOfInteger::SetRow(int theRow, const std::vector<int>
   else {
     SALOMEDS::LongSeq_var aSeq = new SALOMEDS::LongSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = theData[i];
+    for (i = 0; i < aLength; i++) aSeq[i] = theData[i];
     SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRow(theRow, aSeq);
   }
 }
@@ -258,15 +288,16 @@ std::vector<int> SALOMEDS_AttributeTableOfInteger::GetRow(int theRow)
 {
   std::vector<int> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfInteger) aRow; 
     aRow = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetRowData(theRow);
     aLength = aRow->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aRow->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aRow->Value(i));
   }
   else {
     SALOMEDS::LongSeq_var aRow = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRow(theRow);
-    for(i = 0; i < aLength; i++) aVector.push_back(aRow[i]);
+    for (i = 0; i < aLength; i++) aVector.push_back(aRow[i]);
   }
 
   return aVector;
@@ -274,9 +305,10 @@ std::vector<int> SALOMEDS_AttributeTableOfInteger::GetRow(int theRow)
 
 void SALOMEDS_AttributeTableOfInteger::AddColumn(const std::vector<int>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfInteger) aColumn = new TColStd_HSequenceOfInteger;
@@ -298,9 +330,10 @@ void SALOMEDS_AttributeTableOfInteger::AddColumn(const std::vector<int>& theData
 
 void SALOMEDS_AttributeTableOfInteger::SetColumn(int theColumn, const std::vector<int>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfInteger) aColumn = new TColStd_HSequenceOfInteger;
@@ -315,7 +348,7 @@ void SALOMEDS_AttributeTableOfInteger::SetColumn(int theColumn, const std::vecto
   else {
     SALOMEDS::LongSeq_var aColumn = new SALOMEDS::LongSeq();
     aColumn->length(aLength);
-    for(i = 0; i < aLength; i++) aColumn[i] = theData[i];
+    for (i = 0; i < aLength; i++) aColumn[i] = theData[i];
     SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRow(theColumn, aColumn);
   }
 }
@@ -324,26 +357,29 @@ std::vector<int> SALOMEDS_AttributeTableOfInteger::GetColumn(int theColumn)
 {
   std::vector<int> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfInteger) aColumn; 
     aColumn = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetColumnData(theColumn);
     aLength = aColumn->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aColumn->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aColumn->Value(i));
   }
   else {
     SALOMEDS::LongSeq_var aColumn = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetColumn(theColumn);
-    for(i = 0; i < aLength; i++) aVector.push_back(aColumn[i]);
+    for (i = 0; i < aLength; i++) aVector.push_back(aColumn[i]);
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfInteger::PutValue(int theValue, int theRow, int theColumn)
 {
-  CheckLocked();
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     try {
-      Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->PutValue(theValue, theRow, theColumn);
-    }   
+      Handle(SALOMEDSImpl_AttributeTableOfInteger)::
+        DownCast(_local_impl)->PutValue(theValue, theRow, theColumn);
+    }
     catch(...) {
       throw SALOMEDS::AttributeTableOfInteger::IncorrectIndex();
     }
@@ -356,7 +392,10 @@ void SALOMEDS_AttributeTableOfInteger::PutValue(int theValue, int theRow, int th
 bool SALOMEDS_AttributeTableOfInteger::HasValue(int theRow, int theColumn)
 {
   bool ret;
-  if(_isLocal) ret = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->HasValue(theRow, theColumn);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->HasValue(theRow, theColumn);
+  }
   else ret = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->HasValue(theRow, theColumn);
   return ret;
 }
@@ -364,9 +403,11 @@ bool SALOMEDS_AttributeTableOfInteger::HasValue(int theRow, int theColumn)
 int SALOMEDS_AttributeTableOfInteger::GetValue(int theRow, int theColumn)
 {
   int aValue;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
-      aValue = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetValue(theRow, theColumn);
+      aValue = Handle(SALOMEDSImpl_AttributeTableOfInteger)::
+        DownCast(_local_impl)->GetValue(theRow, theColumn);
     }   
     catch(...) {
       throw SALOMEDS::AttributeTableOfInteger::IncorrectIndex();
@@ -382,21 +423,26 @@ std::vector<int> SALOMEDS_AttributeTableOfInteger::GetRowSetIndices(int theRow)
 {
   std::vector<int> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfInteger) aSet; 
     aSet = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetSetRowIndices(theRow);
     aLength = aSet->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aSet->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSet->Value(i));
   }
   else {
-    SALOMEDS::LongSeq_var aSet = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowSetIndices(theRow);
-    for(i = 0; i < aLength; i++) aVector.push_back(aSet[i]);
+    SALOMEDS::LongSeq_var aSet =
+      SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowSetIndices(theRow);
+    for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]);
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfInteger::SetNbColumns(int theNbColumns)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetNbColumns(theNbColumns);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetNbColumns(theNbColumns);
+  }
   else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetNbColumns(theNbColumns);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTableOfReal.cxx b/src/SALOMEDS/SALOMEDS_AttributeTableOfReal.cxx
index 68ccc2d428e9fdc581c990bed141774e0ca5c097..bb7cf1f26a0772eef615f41afa0deb4dd086759d 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTableOfReal.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTableOfReal.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTableOfReal.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
@@ -30,8 +31,8 @@
 #include <TColStd_HSequenceOfExtendedString.hxx>
 
 
-SALOMEDS_AttributeTableOfReal
-::SALOMEDS_AttributeTableOfReal(const Handle(SALOMEDSImpl_AttributeTableOfReal)& theAttr)
+SALOMEDS_AttributeTableOfReal::SALOMEDS_AttributeTableOfReal
+                  (const Handle(SALOMEDSImpl_AttributeTableOfReal)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -45,25 +46,34 @@ SALOMEDS_AttributeTableOfReal::~SALOMEDS_AttributeTableOfReal()
 
 void SALOMEDS_AttributeTableOfReal::SetTitle(const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;     
+    Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetTitle(theTitle.c_str());
 }
 
 std::string SALOMEDS_AttributeTableOfReal::GetTitle()
 {
   std::string aStr;
-  if(_isLocal) 
-    aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetTitle()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfReal)::
+                                   DownCast(_local_impl)->GetTitle()).ToCString();
+  }
   else aStr = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetTitle();
   return aStr;
 }
 
 void SALOMEDS_AttributeTableOfReal::SetRowTitle(int theIndex, const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetRowTitle(theIndex, 
-                                                                                            (char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;     
+    Handle(SALOMEDSImpl_AttributeTableOfReal)::
+      DownCast(_local_impl)->SetRowTitle(theIndex, (char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetRowTitle(theIndex, theTitle.c_str());
 }
 
@@ -71,59 +81,65 @@ void SALOMEDS_AttributeTableOfReal::SetRowTitles(const std::vector<std::string>&
 {
   CheckLocked();
   int aLength = theTitles.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;     
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetRowTitles(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetRowTitles(aSeq);
   }
-  
 }
 
 std::vector<std::string> SALOMEDS_AttributeTableOfReal::GetRowTitles()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetRowTitles();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetRowTitles();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfReal::SetColumnTitle(int theIndex, const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetColumnTitle(theIndex, 
-                                                                                               (char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeTableOfReal)::
+      DownCast(_local_impl)->SetColumnTitle(theIndex, (char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetColumnTitle(theIndex, theTitle.c_str());
 }
 
 void SALOMEDS_AttributeTableOfReal::SetColumnTitles(const std::vector<std::string>& theTitles)
 {
-  CheckLocked();
   int aLength = theTitles.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetColumnTitles(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetColumnTitles(aSeq);
   }
 }
@@ -132,41 +148,46 @@ std::vector<std::string> SALOMEDS_AttributeTableOfReal::GetColumnTitles()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetColumnTitles();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetColumnTitles();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfReal::SetRowUnit(int theIndex, const std::string& theUnit)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetRowUnit(theIndex, 
-                                                                                           (char*)theUnit.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeTableOfReal)::
+      DownCast(_local_impl)->SetRowUnit(theIndex, (char*)theUnit.c_str());
+  }
   else SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetRowUnit(theIndex, theUnit.c_str());
 }
 
 void SALOMEDS_AttributeTableOfReal::SetRowUnits(const std::vector<std::string>& theUnits)
 {
-  CheckLocked();
   int aLength = theUnits.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theUnits[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theUnits[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetRowUnits(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theUnits[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theUnits[i].c_str();
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetRowUnits(aSeq);
   }
 }
@@ -175,16 +196,17 @@ std::vector<std::string> SALOMEDS_AttributeTableOfReal::GetRowUnits()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetRowUnits();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetRowUnits();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back(TCollection_AsciiString((char*)aSeq[i].in()).ToCString());
+    for (i = 0; i < aLength; i++) aVector.push_back(TCollection_AsciiString((char*)aSeq[i].in()).ToCString());
   }
   return aVector;
 }
@@ -192,7 +214,10 @@ std::vector<std::string> SALOMEDS_AttributeTableOfReal::GetRowUnits()
 int SALOMEDS_AttributeTableOfReal::GetNbRows()
 {
   int aNb;
-  if(_isLocal) aNb = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetNbRows();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aNb = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetNbRows();
+  }
   else aNb = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetNbRows();
   return aNb;
 }
@@ -200,17 +225,20 @@ int SALOMEDS_AttributeTableOfReal::GetNbRows()
 int SALOMEDS_AttributeTableOfReal::GetNbColumns()
 {  
   int aNb;
-  if(_isLocal) aNb = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetNbColumns();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aNb = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetNbColumns();
+  }
   else aNb = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetNbColumns();
   return aNb;
-  
 }
 
 void SALOMEDS_AttributeTableOfReal::AddRow(const std::vector<double>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(SALOMEDSImpl_AttributeTableOfReal) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfReal) aRow = new TColStd_HSequenceOfReal;
@@ -225,16 +253,17 @@ void SALOMEDS_AttributeTableOfReal::AddRow(const std::vector<double>& theData)
   else {
     SALOMEDS::DoubleSeq_var aSeq = new SALOMEDS::DoubleSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = theData[i];
+    for (i = 0; i < aLength; i++) aSeq[i] = theData[i];
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->AddRow(aSeq);
   }
 }
 
 void SALOMEDS_AttributeTableOfReal::SetRow(int theRow, const std::vector<double>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(SALOMEDSImpl_AttributeTableOfReal) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfReal) aRow = new TColStd_HSequenceOfReal;
@@ -249,7 +278,7 @@ void SALOMEDS_AttributeTableOfReal::SetRow(int theRow, const std::vector<double>
   else {
     SALOMEDS::DoubleSeq_var aSeq = new SALOMEDS::DoubleSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = theData[i];
+    for (i = 0; i < aLength; i++) aSeq[i] = theData[i];
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetRow(theRow, aSeq);
   }
 }
@@ -258,15 +287,16 @@ std::vector<double> SALOMEDS_AttributeTableOfReal::GetRow(int theRow)
 {
   std::vector<double> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfReal) aRow; 
     aRow = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetRowData(theRow);
     aLength = aRow->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aRow->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aRow->Value(i));
   }
   else {
     SALOMEDS::DoubleSeq_var aRow = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetRow(theRow);
-    for(i = 0; i < aLength; i++) aVector.push_back(aRow[i]);
+    for (i = 0; i < aLength; i++) aVector.push_back(aRow[i]);
   }
 
   return aVector;
@@ -274,9 +304,10 @@ std::vector<double> SALOMEDS_AttributeTableOfReal::GetRow(int theRow)
 
 void SALOMEDS_AttributeTableOfReal::AddColumn(const std::vector<double>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(SALOMEDSImpl_AttributeTableOfReal) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfReal) aColumn = new TColStd_HSequenceOfReal;
@@ -291,16 +322,17 @@ void SALOMEDS_AttributeTableOfReal::AddColumn(const std::vector<double>& theData
   else {
     SALOMEDS::DoubleSeq_var aColumn = new SALOMEDS::DoubleSeq();
     aColumn->length(aLength);
-    for(i = 0; i < aLength; i++) aColumn[i] = theData[i];
+    for (i = 0; i < aLength; i++) aColumn[i] = theData[i];
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->AddColumn(aColumn);
   }
 }
 
 void SALOMEDS_AttributeTableOfReal::SetColumn(int theColumn, const std::vector<double>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     Handle(SALOMEDSImpl_AttributeTableOfReal) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfReal) aColumn = new TColStd_HSequenceOfReal;
@@ -315,7 +347,7 @@ void SALOMEDS_AttributeTableOfReal::SetColumn(int theColumn, const std::vector<d
   else {
     SALOMEDS::DoubleSeq_var aColumn = new SALOMEDS::DoubleSeq();
     aColumn->length(aLength);
-    for(i = 0; i < aLength; i++) aColumn[i] = theData[i];
+    for (i = 0; i < aLength; i++) aColumn[i] = theData[i];
     SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetRow(theColumn, aColumn);
   }
 }
@@ -324,25 +356,28 @@ std::vector<double> SALOMEDS_AttributeTableOfReal::GetColumn(int theColumn)
 {
   std::vector<double> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfReal) aColumn; 
     aColumn = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetColumnData(theColumn);
     aLength = aColumn->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aColumn->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aColumn->Value(i));
   }
   else {
     SALOMEDS::DoubleSeq_var aColumn = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetColumn(theColumn);
-    for(i = 0; i < aLength; i++) aVector.push_back(aColumn[i]);
+    for (i = 0; i < aLength; i++) aVector.push_back(aColumn[i]);
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfReal::PutValue(double theValue, int theRow, int theColumn)
 {
-  CheckLocked();
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock; 
     try {
-      Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->PutValue(theValue, theRow, theColumn);
+      Handle(SALOMEDSImpl_AttributeTableOfReal)::
+        DownCast(_local_impl)->PutValue(theValue, theRow, theColumn);
     }   
     catch(...) {
       throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
@@ -356,7 +391,10 @@ void SALOMEDS_AttributeTableOfReal::PutValue(double theValue, int theRow, int th
 bool SALOMEDS_AttributeTableOfReal::HasValue(int theRow, int theColumn)
 {
   bool ret;
-  if(_isLocal) ret = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->HasValue(theRow, theColumn);
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    ret = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->HasValue(theRow, theColumn);
+  }
   else ret = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->HasValue(theRow, theColumn);
   return ret;
 }
@@ -364,7 +402,8 @@ bool SALOMEDS_AttributeTableOfReal::HasValue(int theRow, int theColumn)
 double SALOMEDS_AttributeTableOfReal::GetValue(int theRow, int theColumn)
 {
   double aValue;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     try {
       aValue = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetValue(theRow, theColumn);
     }   
@@ -382,21 +421,25 @@ std::vector<int> SALOMEDS_AttributeTableOfReal::GetRowSetIndices(int theRow)
 {
   std::vector<int> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
     Handle(TColStd_HSequenceOfInteger) aSet; 
     aSet = Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->GetSetRowIndices(theRow);
     aLength = aSet->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aSet->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSet->Value(i));
   }
   else {
     SALOMEDS::LongSeq_var aSet = SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->GetRowSetIndices(theRow);
-    for(i = 0; i < aLength; i++) aVector.push_back(aSet[i]);
+    for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]);
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfReal::SetNbColumns(int theNbColumns)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetNbColumns(theNbColumns);
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    Handle(SALOMEDSImpl_AttributeTableOfReal)::DownCast(_local_impl)->SetNbColumns(theNbColumns);
+  }
   else SALOMEDS::AttributeTableOfReal::_narrow(_corba_impl)->SetNbColumns(theNbColumns);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTableOfString.cxx b/src/SALOMEDS/SALOMEDS_AttributeTableOfString.cxx
index 0978252c7c92a923cef0e7ce50da96e522b35941..a999892a4f9c530c3fa3ace5f64fbba3a8f4fd51 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTableOfString.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTableOfString.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTableOfString.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -30,12 +31,13 @@
 #include <TColStd_HSequenceOfReal.hxx>
 #include <TColStd_HSequenceOfExtendedString.hxx>
  
-SALOMEDS_AttributeTableOfString
-::SALOMEDS_AttributeTableOfString(const Handle(SALOMEDSImpl_AttributeTableOfString)& theAttr)
+SALOMEDS_AttributeTableOfString::SALOMEDS_AttributeTableOfString
+                  (const Handle(SALOMEDSImpl_AttributeTableOfString)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
-SALOMEDS_AttributeTableOfString::SALOMEDS_AttributeTableOfString(SALOMEDS::AttributeTableOfString_ptr theAttr)
+SALOMEDS_AttributeTableOfString::SALOMEDS_AttributeTableOfString
+                  (SALOMEDS::AttributeTableOfString_ptr theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -45,85 +47,99 @@ SALOMEDS_AttributeTableOfString::~SALOMEDS_AttributeTableOfString()
 
 void SALOMEDS_AttributeTableOfString::SetTitle(const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetTitle(theTitle.c_str());
 }
 
 std::string SALOMEDS_AttributeTableOfString::GetTitle()
 {
   std::string aStr;
-  if(_isLocal) 
-    aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetTitle()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfString)::
+                                   DownCast(_local_impl)->GetTitle()).ToCString();
+  }
   else aStr = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetTitle();
   return aStr;
 }
 
 void SALOMEDS_AttributeTableOfString::SetRowTitle(int theIndex, const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetRowTitle(theIndex, 
-                                                                                              (char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfString)::
+      DownCast(_local_impl)->SetRowTitle(theIndex, (char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetRowTitle(theIndex, theTitle.c_str());
 }
 
 void SALOMEDS_AttributeTableOfString::SetRowTitles(const std::vector<std::string>& theTitles)
 {
-  CheckLocked();
   int aLength = theTitles.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetRowTitles(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetRowTitles(aSeq);
   }
-  
 }
 
 std::vector<std::string> SALOMEDS_AttributeTableOfString::GetRowTitles()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetRowTitles();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetRowTitles();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfString::SetColumnTitle(int theIndex, const std::string& theTitle)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetColumnTitle(theIndex, 
-                                                                                                 (char*)theTitle.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfString)::
+      DownCast(_local_impl)->SetColumnTitle(theIndex, (char*)theTitle.c_str());
+  }
   else SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetColumnTitle(theIndex, theTitle.c_str());
 }
 
 void SALOMEDS_AttributeTableOfString::SetColumnTitles(const std::vector<std::string>& theTitles)
 {
-  CheckLocked();
   int aLength = theTitles.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theTitles[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetColumnTitles(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theTitles[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetColumnTitles(aSeq);
   }
 }
@@ -132,41 +148,46 @@ std::vector<std::string> SALOMEDS_AttributeTableOfString::GetColumnTitles()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetColumnTitles();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetColumnTitles();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfString::SetRowUnit(int theIndex, const std::string& theUnit)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetRowUnit(theIndex, 
-                                                                                             (char*)theUnit.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfString)::
+      DownCast(_local_impl)->SetRowUnit(theIndex, (char*)theUnit.c_str());
+  }
   else SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetRowUnit(theIndex, theUnit.c_str());
 }
 
 void SALOMEDS_AttributeTableOfString::SetRowUnits(const std::vector<std::string>& theUnits)
 {
-  CheckLocked();
   int aLength = theUnits.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString;
-    for(i = 0; i < aLength; i++) aSeq->Append((char*)theUnits[i].c_str());
+    for (i = 0; i < aLength; i++) aSeq->Append((char*)theUnits[i].c_str());
     Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetRowUnits(aSeq);
   }
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theUnits[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theUnits[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetRowUnits(aSeq);
   }
 }
@@ -175,16 +196,17 @@ std::vector<std::string> SALOMEDS_AttributeTableOfString::GetRowUnits()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetRowUnits();
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aSeq->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetRowUnits();
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
@@ -192,7 +214,10 @@ std::vector<std::string> SALOMEDS_AttributeTableOfString::GetRowUnits()
 int SALOMEDS_AttributeTableOfString::GetNbRows()
 {
   int aNb;
-  if(_isLocal) aNb = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetNbRows();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aNb = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetNbRows();
+  }
   else aNb = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetNbRows();
   return aNb;
 }
@@ -200,17 +225,20 @@ int SALOMEDS_AttributeTableOfString::GetNbRows()
 int SALOMEDS_AttributeTableOfString::GetNbColumns()
 {  
   int aNb;
-  if(_isLocal) aNb = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetNbColumns();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aNb = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetNbColumns();
+  }
   else aNb = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetNbColumns();
   return aNb;
-  
 }
 
 void SALOMEDS_AttributeTableOfString::AddRow(const std::vector<std::string>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfString) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfExtendedString) aRow = new TColStd_HSequenceOfExtendedString;
@@ -225,16 +253,17 @@ void SALOMEDS_AttributeTableOfString::AddRow(const std::vector<std::string>& the
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theData[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theData[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->AddRow(aSeq);
   }
 }
 
 void SALOMEDS_AttributeTableOfString::SetRow(int theRow, const std::vector<std::string>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfString) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfExtendedString) aRow = new TColStd_HSequenceOfExtendedString;
@@ -249,7 +278,7 @@ void SALOMEDS_AttributeTableOfString::SetRow(int theRow, const std::vector<std::
   else {
     SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq();
     aSeq->length(aLength);
-    for(i = 0; i < aLength; i++) aSeq[i] = (char*)theData[i].c_str();
+    for (i = 0; i < aLength; i++) aSeq[i] = (char*)theData[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetRow(theRow, aSeq);
   }
 }
@@ -258,15 +287,16 @@ std::vector<std::string> SALOMEDS_AttributeTableOfString::GetRow(int theRow)
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aRow; 
     aRow = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetRowData(theRow);
     aLength = aRow->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aRow->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(TCollection_AsciiString(aRow->Value(i)).ToCString());
   }
   else {
     SALOMEDS::StringSeq_var aRow = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetRow(theRow);
-    for(i = 0; i < aLength; i++) aVector.push_back((char*)aRow[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aRow[i].in());
   }
 
   return aVector;
@@ -274,9 +304,10 @@ std::vector<std::string> SALOMEDS_AttributeTableOfString::GetRow(int theRow)
 
 void SALOMEDS_AttributeTableOfString::AddColumn(const std::vector<std::string>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfString) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfExtendedString) aColumn = new TColStd_HSequenceOfExtendedString;
@@ -291,16 +322,17 @@ void SALOMEDS_AttributeTableOfString::AddColumn(const std::vector<std::string>&
   else {
     SALOMEDS::StringSeq_var aColumn = new SALOMEDS::StringSeq();
     aColumn->length(aLength);
-    for(i = 0; i < aLength; i++) aColumn[i] = (char*)theData[i].c_str();
+    for (i = 0; i < aLength; i++) aColumn[i] = (char*)theData[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->AddColumn(aColumn);
   }
 }
 
 void SALOMEDS_AttributeTableOfString::SetColumn(int theColumn, const std::vector<std::string>& theData)
 {
-  CheckLocked();
   int aLength = theData.size(), i;
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTableOfString) aTable;
     aTable = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl);
     Handle(TColStd_HSequenceOfExtendedString) aColumn = new TColStd_HSequenceOfExtendedString;
@@ -315,7 +347,7 @@ void SALOMEDS_AttributeTableOfString::SetColumn(int theColumn, const std::vector
   else {
     SALOMEDS::StringSeq_var aColumn = new SALOMEDS::StringSeq();
     aColumn->length(aLength);
-    for(i = 0; i < aLength; i++) aColumn[i] = (char*)theData[i].c_str();
+    for (i = 0; i < aLength; i++) aColumn[i] = (char*)theData[i].c_str();
     SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetRow(theColumn, aColumn);
   }
 }
@@ -324,27 +356,31 @@ std::vector<std::string> SALOMEDS_AttributeTableOfString::GetColumn(int theColum
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfExtendedString) aColumn; 
-    aColumn = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetColumnData(theColumn);
+    aColumn = Handle(SALOMEDSImpl_AttributeTableOfString)::
+      DownCast(_local_impl)->GetColumnData(theColumn);
     aLength = aColumn->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString(aColumn->Value(i)).ToCString());
+    for (i = 1; i <= aLength; i++)
+      aVector.push_back(TCollection_AsciiString(aColumn->Value(i)).ToCString());
   }
   else {
-    SALOMEDS::StringSeq_var aColumn = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetColumn(theColumn);
-    for(i = 0; i < aLength; i++) aVector.push_back(aColumn[i].in());
+    SALOMEDS::StringSeq_var aColumn =
+      SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetColumn(theColumn);
+    for (i = 0; i < aLength; i++) aVector.push_back(aColumn[i].in());
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfString::PutValue(const std::string& theValue, int theRow, int theColumn)
 {
-  CheckLocked();
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     try {
-      Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->PutValue((char*)theValue.c_str(), 
-                                                                                  theRow, 
-                                                                                  theColumn);
+      Handle(SALOMEDSImpl_AttributeTableOfString)::
+        DownCast(_local_impl)->PutValue((char*)theValue.c_str(), theRow, theColumn);
     }   
     catch(...) {
       throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
@@ -358,7 +394,10 @@ void SALOMEDS_AttributeTableOfString::PutValue(const std::string& theValue, int
 bool SALOMEDS_AttributeTableOfString::HasValue(int theRow, int theColumn)
 {
   bool ret;
-  if(_isLocal) ret = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->HasValue(theRow, theColumn);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->HasValue(theRow, theColumn);
+  }
   else ret = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->HasValue(theRow, theColumn);
   return ret;
 }
@@ -366,11 +405,11 @@ bool SALOMEDS_AttributeTableOfString::HasValue(int theRow, int theColumn)
 std::string SALOMEDS_AttributeTableOfString::GetValue(int theRow, int theColumn)
 {
   std::string aValue;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
-      aValue = 
-          TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetValue(theRow,
-                                                                                                              theColumn)).ToCString();
+      aValue = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfString)::
+                                       DownCast(_local_impl)->GetValue(theRow, theColumn)).ToCString();
     }   
     catch(...) {
       throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
@@ -386,21 +425,26 @@ std::vector<int> SALOMEDS_AttributeTableOfString::GetRowSetIndices(int theRow)
 {
   std::vector<int> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfInteger) aSet; 
     aSet = Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->GetSetRowIndices(theRow);
     aLength = aSet->Length();
-    for(i = 1; i<= aLength; i++) aVector.push_back(aSet->Value(i));
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSet->Value(i));
   }
   else {
-    SALOMEDS::LongSeq_var aSet = SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetRowSetIndices(theRow);
-    for(i = 0; i < aLength; i++) aVector.push_back(aSet[i]);
+    SALOMEDS::LongSeq_var aSet =
+      SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->GetRowSetIndices(theRow);
+    for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]);
   }
   return aVector;
 }
 
 void SALOMEDS_AttributeTableOfString::SetNbColumns(int theNbColumns)
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetNbColumns(theNbColumns);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTableOfString)::DownCast(_local_impl)->SetNbColumns(theNbColumns);
+  }
   else SALOMEDS::AttributeTableOfString::_narrow(_corba_impl)->SetNbColumns(theNbColumns);
 }

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTarget.cxx b/src/SALOMEDS/SALOMEDS_AttributeTarget.cxx
index 62c6ce0218b7947778e6f2eacd73964eac1b3b8c..8511dac238ce4415efa33435b3348d1f8d8b00fd 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTarget.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTarget.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTarget.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TColStd_HSequenceOfTransient.hxx>
 
@@ -44,7 +45,10 @@ void SALOMEDS_AttributeTarget::Add(const _PTR(SObject)& theObject)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
 
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTarget)::DownCast(_local_impl)->Add(aSO->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTarget)::DownCast(_local_impl)->Add(aSO->GetLocalImpl());
+  }
   else SALOMEDS::AttributeTarget::_narrow(_corba_impl)->Add(aSO->GetCORBAImpl());
 }
 
@@ -54,10 +58,12 @@ std::vector<_PTR(SObject)> SALOMEDS_AttributeTarget::Get()
   int aLength, i;
   SALOMEDSClient_SObject* aSO = NULL;
   
-  if(_isLocal) {
-    Handle(TColStd_HSequenceOfTransient) aSeq = Handle(SALOMEDSImpl_AttributeTarget)::DownCast(_local_impl)->Get();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(TColStd_HSequenceOfTransient) aSeq =
+      Handle(SALOMEDSImpl_AttributeTarget)::DownCast(_local_impl)->Get();
     aLength = aSeq->Length();
-    for(i=1; i<=aLength; i++) {
+    for (i = 1; i <= aLength; i++) {
       aSO = new SALOMEDS_SObject(Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i)));
       aVector.push_back(_PTR(SObject)(aSO));
     }
@@ -66,7 +72,7 @@ std::vector<_PTR(SObject)> SALOMEDS_AttributeTarget::Get()
     SALOMEDS::Study::ListOfSObject_var aSeq = SALOMEDS::AttributeTarget::_narrow(_corba_impl)->Get();
     aLength = aSeq->length();
     aSO = new SALOMEDS_SObject(aSeq[i].in());
-    for(i = 0; i<aLength; i++) aVector.push_back(_PTR(SObject)(aSO));
+    for (i = 0; i < aLength; i++) aVector.push_back(_PTR(SObject)(aSO));
   }
 
   return aVector;
@@ -76,7 +82,9 @@ void SALOMEDS_AttributeTarget::Remove(const _PTR(SObject)& theObject)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
 
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTarget)::DownCast(_local_impl)->Remove(aSO->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTarget)::DownCast(_local_impl)->Remove(aSO->GetLocalImpl());
+  }
   else SALOMEDS::AttributeTarget::_narrow(_corba_impl)->Remove(aSO->GetCORBAImpl());
 }
-

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTextColor.cxx b/src/SALOMEDS/SALOMEDS_AttributeTextColor.cxx
index c2da3fd0e09a3518415dcf6be47105f12cdbdaeb..6c23440b769f4ffc86bf3701ea10e09002e5a0ca 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTextColor.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTextColor.cxx
@@ -22,10 +22,12 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTextColor.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TColStd_HArray1OfReal.hxx>
 
-SALOMEDS_AttributeTextColor::SALOMEDS_AttributeTextColor(const Handle(SALOMEDSImpl_AttributeTextColor)& theAttr)
+SALOMEDS_AttributeTextColor::SALOMEDS_AttributeTextColor
+                  (const Handle(SALOMEDSImpl_AttributeTextColor)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -40,8 +42,10 @@ SALOMEDS_AttributeTextColor::~SALOMEDS_AttributeTextColor()
 STextColor SALOMEDS_AttributeTextColor::TextColor()
 {
   STextColor aColor;
-  if(_isLocal) {
-    Handle(TColStd_HArray1OfReal) aSeq = Handle(SALOMEDSImpl_AttributeTextColor)::DownCast(_local_impl)->TextColor();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(TColStd_HArray1OfReal) aSeq =
+      Handle(SALOMEDSImpl_AttributeTextColor)::DownCast(_local_impl)->TextColor();
     aColor.R = aSeq->Value(1);
     aColor.G = aSeq->Value(2);
     aColor.B = aSeq->Value(3); 
@@ -54,11 +58,12 @@ STextColor SALOMEDS_AttributeTextColor::TextColor()
   }
   return aColor;
 }
- 
+
 void SALOMEDS_AttributeTextColor::SetTextColor(STextColor value)
 {
-  CheckLocked();
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HArray1OfReal) aSeq = new TColStd_HArray1OfReal(1, 3);
     aSeq->SetValue(1, value.R);
     aSeq->SetValue(2, value.G);

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTextHighlightColor.cxx b/src/SALOMEDS/SALOMEDS_AttributeTextHighlightColor.cxx
index 7d2ea235232f92f21d64ead474fd4a04541ac3b4..d6d1a42869e3677117c933abc2202855aab27f62 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTextHighlightColor.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTextHighlightColor.cxx
@@ -22,14 +22,17 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTextHighlightColor.hxx"
+#include "SALOMEDS.hxx"
 
 #include <TColStd_HArray1OfReal.hxx>
 
-SALOMEDS_AttributeTextHighlightColor::SALOMEDS_AttributeTextHighlightColor(const Handle(SALOMEDSImpl_AttributeTextHighlightColor)& theAttr)
+SALOMEDS_AttributeTextHighlightColor::SALOMEDS_AttributeTextHighlightColor
+                  (const Handle(SALOMEDSImpl_AttributeTextHighlightColor)& theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
-SALOMEDS_AttributeTextHighlightColor::SALOMEDS_AttributeTextHighlightColor(SALOMEDS::AttributeTextHighlightColor_ptr theAttr)
+SALOMEDS_AttributeTextHighlightColor::SALOMEDS_AttributeTextHighlightColor
+                  (SALOMEDS::AttributeTextHighlightColor_ptr theAttr)
 :SALOMEDS_GenericAttribute(theAttr)
 {}
 
@@ -40,7 +43,8 @@ SALOMEDS_AttributeTextHighlightColor::~SALOMEDS_AttributeTextHighlightColor()
 STextColor SALOMEDS_AttributeTextHighlightColor::TextHighlightColor()
 {
   STextColor aColor;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HArray1OfReal) aSeq;
     aSeq = Handle(SALOMEDSImpl_AttributeTextHighlightColor)::DownCast(_local_impl)->TextHighlightColor();
     aColor.R = aSeq->Value(1);
@@ -48,17 +52,20 @@ STextColor SALOMEDS_AttributeTextHighlightColor::TextHighlightColor()
     aColor.B = aSeq->Value(3); 
   }
   else {
-    SALOMEDS::Color anImplColor = SALOMEDS::AttributeTextHighlightColor::_narrow(_corba_impl)->TextHighlightColor();
+    SALOMEDS::Color anImplColor =
+      SALOMEDS::AttributeTextHighlightColor::_narrow(_corba_impl)->TextHighlightColor();
     aColor.R = anImplColor.R;
     aColor.G = anImplColor.G;
     aColor.B = anImplColor.B;
   }
   return aColor;
 }
- 
+
 void SALOMEDS_AttributeTextHighlightColor::SetTextHighlightColor(STextColor value)
 {
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(TColStd_HArray1OfReal) aSeq = new TColStd_HArray1OfReal(1, 3);
     aSeq->SetValue(1, value.R);
     aSeq->SetValue(2, value.G);

diff --git a/src/SALOMEDS/SALOMEDS_AttributeTreeNode.cxx b/src/SALOMEDS/SALOMEDS_AttributeTreeNode.cxx
index e23f62e09639d38cb64a90df145968618eeb2a5a..2d2df71641a4dbe4b607cabd656bb729f69391c7 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeTreeNode.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeTreeNode.cxx
@@ -22,8 +22,10 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeTreeNode.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
+
 #include <TCollection_AsciiString.hxx>
 #include <TCollection_ExtendedString.hxx>
 #include <Standard_GUID.hxx>
@@ -47,7 +49,9 @@ SALOMEDS_AttributeTreeNode::~SALOMEDS_AttributeTreeNode()
 void SALOMEDS_AttributeTreeNode::SetFather(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, aFather;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aFather = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -63,8 +67,10 @@ void SALOMEDS_AttributeTreeNode::SetFather(const _PTR(AttributeTreeNode)& value)
 bool SALOMEDS_AttributeTreeNode::HasFather()
 {
   bool ret;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     ret = aNode->HasFather();
   }
   else {
@@ -77,8 +83,10 @@ bool SALOMEDS_AttributeTreeNode::HasFather()
 _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetFather()
 {
   SALOMEDSClient_AttributeTreeNode* aTN  = NULL;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aTN = new SALOMEDS_AttributeTreeNode(aNode->GetFather());
   }
   else {
@@ -91,7 +99,9 @@ _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetFather()
 void SALOMEDS_AttributeTreeNode::SetPrevious(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, aPrev;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aPrev = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -107,8 +117,10 @@ void SALOMEDS_AttributeTreeNode::SetPrevious(const _PTR(AttributeTreeNode)& valu
 bool SALOMEDS_AttributeTreeNode::HasPrevious()
 {
   bool ret;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     ret = aNode->HasPrevious();
   }
   else {
@@ -121,8 +133,10 @@ bool SALOMEDS_AttributeTreeNode::HasPrevious()
 _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetPrevious()
 {
   SALOMEDSClient_AttributeTreeNode* aTN = NULL;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aTN = new SALOMEDS_AttributeTreeNode(aNode->GetPrevious());
   }
   else {
@@ -135,7 +149,9 @@ _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetPrevious()
 void SALOMEDS_AttributeTreeNode::SetNext(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, aNext;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aNext = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -151,8 +167,10 @@ void SALOMEDS_AttributeTreeNode::SetNext(const _PTR(AttributeTreeNode)& value)
 bool SALOMEDS_AttributeTreeNode::HasNext()
 {
   bool ret;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     ret = aNode->HasNext();
   }
   else {
@@ -165,8 +183,10 @@ bool SALOMEDS_AttributeTreeNode::HasNext()
 _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetNext()
 {
   SALOMEDSClient_AttributeTreeNode* aTN = NULL;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aTN = new SALOMEDS_AttributeTreeNode(aNode->GetNext());
   }
   else {
@@ -179,7 +199,9 @@ _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetNext()
 void SALOMEDS_AttributeTreeNode::SetFirst(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, aFirst;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aFirst = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -195,8 +217,10 @@ void SALOMEDS_AttributeTreeNode::SetFirst(const _PTR(AttributeTreeNode)& value)
 bool SALOMEDS_AttributeTreeNode::HasFirst()
 {
   bool ret;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     ret = aNode->HasFirst();
   }
   else {
@@ -209,8 +233,10 @@ bool SALOMEDS_AttributeTreeNode::HasFirst()
 _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetFirst()
 {
   SALOMEDSClient_AttributeTreeNode* aTN = NULL;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aTN = new SALOMEDS_AttributeTreeNode(aNode->GetFirst());
   }
   else {
@@ -222,8 +248,11 @@ _PTR(AttributeTreeNode) SALOMEDS_AttributeTreeNode::GetFirst()
 
 void SALOMEDS_AttributeTreeNode::SetTreeID(const std::string& value)
 {
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     aNode->SetTreeID(Standard_GUID((char*)value.c_str()));
   }
   else {
@@ -235,8 +264,10 @@ void SALOMEDS_AttributeTreeNode::SetTreeID(const std::string& value)
 std::string SALOMEDS_AttributeTreeNode::GetTreeID()
 {
   TCollection_AsciiString aGUID;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_AttributeTreeNode) aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode) aNode =
+      Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     char guid[40];
     aNode->GetTreeID().ToCString(guid);
     aGUID = TCollection_AsciiString(guid);
@@ -252,7 +283,9 @@ std::string SALOMEDS_AttributeTreeNode::GetTreeID()
 void SALOMEDS_AttributeTreeNode::Append(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -268,7 +301,9 @@ void SALOMEDS_AttributeTreeNode::Append(const _PTR(AttributeTreeNode)& value)
 void SALOMEDS_AttributeTreeNode::Prepend(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -284,7 +319,9 @@ void SALOMEDS_AttributeTreeNode::Prepend(const _PTR(AttributeTreeNode)& value)
 void SALOMEDS_AttributeTreeNode::InsertBefore(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -300,7 +337,9 @@ void SALOMEDS_AttributeTreeNode::InsertBefore(const _PTR(AttributeTreeNode)& val
 void SALOMEDS_AttributeTreeNode::InsertAfter(const _PTR(AttributeTreeNode)& value)
 {
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -315,14 +354,21 @@ void SALOMEDS_AttributeTreeNode::InsertAfter(const _PTR(AttributeTreeNode)& valu
 
 void SALOMEDS_AttributeTreeNode::Remove()
 {
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl)->Remove();
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl)->Remove();
+  }
   else SALOMEDS::AttributeTreeNode::_narrow(_corba_impl)->Remove();
 }
 
 int SALOMEDS_AttributeTreeNode::Depth()
 {
   int aDepth;
-  if(_isLocal) aDepth = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl)->Depth();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aDepth = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl)->Depth();
+  }
   else aDepth =  SALOMEDS::AttributeTreeNode::_narrow(_corba_impl)->Depth();
   return aDepth;
 }
@@ -330,7 +376,10 @@ int SALOMEDS_AttributeTreeNode::Depth()
 bool SALOMEDS_AttributeTreeNode::IsRoot()
 {
   bool ret;
-  if(_isLocal) ret = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl)->IsRoot();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl)->IsRoot();
+  }
   else ret =  SALOMEDS::AttributeTreeNode::_narrow(_corba_impl)->IsRoot();
   return ret;
 }
@@ -339,7 +388,8 @@ bool SALOMEDS_AttributeTreeNode::IsDescendant(const _PTR(AttributeTreeNode)& val
 {
   bool ret;
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -357,7 +407,8 @@ bool SALOMEDS_AttributeTreeNode::IsFather(const _PTR(AttributeTreeNode)& value)
 {
   bool ret;
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -375,7 +426,8 @@ bool SALOMEDS_AttributeTreeNode::IsChild(const _PTR(AttributeTreeNode)& value)
 {
   bool ret;
   SALOMEDS_AttributeTreeNode* aTN = dynamic_cast<SALOMEDS_AttributeTreeNode*>(value.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_AttributeTreeNode) aNode, anOther;
     aNode = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(_local_impl);
     anOther = Handle(SALOMEDSImpl_AttributeTreeNode)::DownCast(aTN->_local_impl);
@@ -391,10 +443,13 @@ bool SALOMEDS_AttributeTreeNode::IsChild(const _PTR(AttributeTreeNode)& value)
 
 std::string SALOMEDS_AttributeTreeNode::Label()
 {
-  TCollection_AsciiString aLabel;
-  if(_isLocal) TDF_Tool::Entry(_local_impl->Label(), aLabel);
+  string aLabel;
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    TCollection_AsciiString anAsciiLabel;
+    TDF_Tool::Entry(_local_impl->Label(), anAsciiLabel);
+    aLabel = std::string(anAsciiLabel.ToCString());
+  }
   else aLabel = SALOMEDS::AttributeTreeNode::_narrow(_corba_impl)->Label();
-  return std::string(aLabel.ToCString());
+  return aLabel;
 }
-
-

diff --git a/src/SALOMEDS/SALOMEDS_AttributeUserID.cxx b/src/SALOMEDS/SALOMEDS_AttributeUserID.cxx
index fe277cc194cd80f16d3f960c17cdceb002c4902e..4d04a19bca8631e2c115619c834a479f027bfe3b 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_AttributeUserID.cxx
+++ b/src/SALOMEDS/SALOMEDS_AttributeUserID.cxx
@@ -22,6 +22,7 @@
 //  Module : SALOME
 
 #include "SALOMEDS_AttributeUserID.hxx"
+#include "SALOMEDS.hxx"
 
 #include <string>
 #include <TCollection_AsciiString.hxx> 
@@ -42,7 +43,8 @@ SALOMEDS_AttributeUserID::~SALOMEDS_AttributeUserID()
 std::string SALOMEDS_AttributeUserID::Value()
 {
   std::string aValue;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     char guid[40];
     Handle(SALOMEDSImpl_AttributeUserID)::DownCast(_local_impl)->Value().ToCString(guid);
     aValue = std::string(guid);
@@ -50,10 +52,14 @@ std::string SALOMEDS_AttributeUserID::Value()
   else aValue = SALOMEDS::AttributeUserID::_narrow(_corba_impl)->Value();
   return aValue;
 }
- 
+
 void SALOMEDS_AttributeUserID::SetValue(const std::string& value)
 {
-  CheckLocked();
-  if(_isLocal) Handle(SALOMEDSImpl_AttributeUserID)::DownCast(_local_impl)->SetValue(Standard_GUID((char*)value.c_str()));
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_AttributeUserID)::
+      DownCast(_local_impl)->SetValue(Standard_GUID((char*)value.c_str()));
+  }
   else SALOMEDS::AttributeUserID::_narrow(_corba_impl)->SetValue(value.c_str());
 }

diff --git a/src/SALOMEDS/SALOMEDS_ChildIterator.cxx b/src/SALOMEDS/SALOMEDS_ChildIterator.cxx
index 1814b6526f49939ed79b6de5aae214ad1062a5ad..a31bbbf188cff3d6c47ff8e3d096e1e8396d4c64 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_ChildIterator.cxx
+++ b/src/SALOMEDS/SALOMEDS_ChildIterator.cxx
@@ -25,11 +25,14 @@
 
 #include "SALOMEDS_ChildIterator.hxx"
 #include "SALOMEDS_SObject.hxx"
+#include "SALOMEDS.hxx"
 
 using namespace std; 
 
 SALOMEDS_ChildIterator::SALOMEDS_ChildIterator(const Handle(SALOMEDSImpl_ChildIterator)& theIterator)
 {
+  SALOMEDS::Locker lock;
+
   _isLocal = true;
   _local_impl = theIterator;
   _corba_impl = SALOMEDS::ChildIterator::_nil();
@@ -49,34 +52,49 @@ SALOMEDS_ChildIterator::~SALOMEDS_ChildIterator()
 
 void SALOMEDS_ChildIterator::Init()
 {
-  if(_isLocal) _local_impl->Init();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Init();
+  }
   else _corba_impl->Init();
 }
 
 void SALOMEDS_ChildIterator::InitEx(bool theAllLevels)
 {
-  if(_isLocal) _local_impl->InitEx(theAllLevels);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->InitEx(theAllLevels);
+  }
   else _corba_impl->InitEx(theAllLevels);
 }
 
 bool SALOMEDS_ChildIterator::More()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->More();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->More();
+  }
   else ret = _corba_impl->More();
   return ret;
 }
 
 void SALOMEDS_ChildIterator::Next() 
 {
-  if(_isLocal) _local_impl->Next();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Next();
+  }
   else _corba_impl->Next();
 }
 
 _PTR(SObject) SALOMEDS_ChildIterator::Value()
 {
   SALOMEDSClient_SObject* aSO;
-  if(_isLocal) aSO = new SALOMEDS_SObject(_local_impl->Value());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aSO = new SALOMEDS_SObject(_local_impl->Value());
+  }
   else aSO = new SALOMEDS_SObject(_corba_impl->Value());
   return _PTR(SObject)(aSO);
 }

diff --git a/src/SALOMEDS/SALOMEDS_Driver_i.cxx b/src/SALOMEDS/SALOMEDS_Driver_i.cxx
index 295781b884c5dbdabbfcb91fed66298884ed26fb..2f4f085cafd11e210ed674aaf88580ed690da481 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_Driver_i.cxx
+++ b/src/SALOMEDS/SALOMEDS_Driver_i.cxx
@@ -41,11 +41,12 @@ unsigned char* SALOMEDS_Driver_i::Save(const Handle(SALOMEDSImpl_SComponent)& th
   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
   SALOMEDS::TMPFile_var aStream;
   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
-  SALOMEDS::unlock(); 
+  SALOMEDS::unlock();
   aStream = _driver->Save(sco.in(), url, isMultiFile);
+  SALOMEDS::lock();
   theStreamLength = aStream->length();
   unsigned char* aRetStream = NULL;
-  if(theStreamLength > 0) {
+  if (theStreamLength > 0) {
     aRetStream = new unsigned char[theStreamLength];
     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
   }
@@ -60,11 +61,12 @@ unsigned char* SALOMEDS_Driver_i::SaveASCII(const Handle(SALOMEDSImpl_SComponent
   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
   SALOMEDS::TMPFile_var aStream;
   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
-  SALOMEDS::unlock(); 
+  SALOMEDS::unlock();
   aStream = _driver->SaveASCII(sco.in(), url, isMultiFile);
+  SALOMEDS::lock();
   theStreamLength = aStream->length();
   unsigned char* aRetStream = NULL;
-  if(theStreamLength > 0) {
+  if (theStreamLength > 0) {
     aRetStream = new unsigned char[theStreamLength];
     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
   }
@@ -79,16 +81,18 @@ bool SALOMEDS_Driver_i::Load(const Handle(SALOMEDSImpl_SComponent)& theComponent
 {
   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
-  CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
+  CORBA::Octet* anOctetBuf = (CORBA::Octet*)theStream;
 
   SALOMEDS::TMPFile_var aStream;
-  if(theStreamLength > 0) 
+  if (theStreamLength > 0) 
     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);  
   else 
     aStream = new SALOMEDS::TMPFile(0);
 
-  SALOMEDS::unlock(); 
-  return _driver->Load(sco.in(), aStream.in(), url, isMultiFile);
+  SALOMEDS::unlock();
+  bool isOk = _driver->Load(sco.in(), aStream.in(), url, isMultiFile);
+  SALOMEDS::lock();
+  return isOk;
 }
 
 bool SALOMEDS_Driver_i::LoadASCII(const Handle(SALOMEDSImpl_SComponent)& theComponent,
@@ -99,7 +103,7 @@ bool SALOMEDS_Driver_i::LoadASCII(const Handle(SALOMEDSImpl_SComponent)& theComp
 {
   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
-  CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
+  CORBA::Octet* anOctetBuf = (CORBA::Octet*)theStream;
 
   SALOMEDS::TMPFile_var aStream;
   if(theStreamLength > 0) 
@@ -107,17 +111,20 @@ bool SALOMEDS_Driver_i::LoadASCII(const Handle(SALOMEDSImpl_SComponent)& theComp
   else 
     aStream = new SALOMEDS::TMPFile(0);
 
-  SALOMEDS::unlock(); 
-  return _driver->LoadASCII(sco.in(), aStream.in(), url, isMultiFile);
+  SALOMEDS::unlock();
+  bool isOk = _driver->LoadASCII(sco.in(), aStream.in(), url, isMultiFile);
+  SALOMEDS::lock();
+  return isOk;
 }
 
 void SALOMEDS_Driver_i::Close(const Handle(SALOMEDSImpl_SComponent)& theComponent)
 {
   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
-  SALOMEDS::unlock(); 
+  SALOMEDS::unlock();
   _driver->Close(sco.in());
+  SALOMEDS::lock();
 }
- 
+
 
 
 TCollection_AsciiString SALOMEDS_Driver_i::IORToLocalPersistentID(const Handle(SALOMEDSImpl_SObject)& theSObject,
@@ -127,8 +134,9 @@ TCollection_AsciiString SALOMEDS_Driver_i::IORToLocalPersistentID(const Handle(S
 {
   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theSObject, _orb);
   CORBA::String_var ior = CORBA::string_dup(IORString.ToCString());
-  SALOMEDS::unlock(); 
+  SALOMEDS::unlock();
   CORBA::String_var pers_string =_driver->IORToLocalPersistentID(so.in(), ior.in(), isMultiFile, isASCII);
+  SALOMEDS::lock();
   return TCollection_AsciiString(pers_string);
 }
 
@@ -140,8 +148,9 @@ TCollection_AsciiString SALOMEDS_Driver_i::LocalPersistentIDToIOR(const Handle(S
 {
   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
   CORBA::String_var pers_string = CORBA::string_dup(aLocalPersistentID.ToCString());
-  SALOMEDS::unlock(); 
-  CORBA::String_var IOR =_driver->LocalPersistentIDToIOR(so.in(), pers_string.in(), isMultiFile, isASCII);
+  SALOMEDS::unlock();
+  CORBA::String_var IOR = _driver->LocalPersistentIDToIOR(so.in(), pers_string.in(), isMultiFile, isASCII);
+  SALOMEDS::lock();
   return TCollection_AsciiString(IOR);
 }
 
@@ -149,7 +158,9 @@ bool SALOMEDS_Driver_i::CanCopy(const Handle(SALOMEDSImpl_SObject)& theObject)
 {
   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
   SALOMEDS::unlock();
-  return _driver->CanCopy(so.in());
+  bool isOk = _driver->CanCopy(so.in());
+  SALOMEDS::lock();
+  return isOk;
 }
 
 
@@ -163,6 +174,7 @@ unsigned char* SALOMEDS_Driver_i::CopyFrom(const Handle(SALOMEDSImpl_SObject)& t
 
   SALOMEDS::unlock();
   aStream = _driver->CopyFrom(so.in(), anObjectID);
+  SALOMEDS::lock();
 
   theObjectID = anObjectID;
   theStreamLength = aStream->length();
@@ -179,7 +191,9 @@ unsigned char* SALOMEDS_Driver_i::CopyFrom(const Handle(SALOMEDSImpl_SObject)& t
 bool SALOMEDS_Driver_i::CanPaste(const TCollection_AsciiString& theComponentName, int theObjectID)
 {
   SALOMEDS::unlock();
-  return _driver->CanPaste(theComponentName.ToCString(), theObjectID);
+  bool canPaste = _driver->CanPaste(theComponentName.ToCString(), theObjectID);
+  SALOMEDS::lock();
+  return canPaste;
 }
 
 TCollection_AsciiString SALOMEDS_Driver_i::PasteInto(const unsigned char* theStream,
@@ -198,6 +212,7 @@ TCollection_AsciiString SALOMEDS_Driver_i::PasteInto(const unsigned char* theStr
 
   SALOMEDS::unlock();
   SALOMEDS::SObject_var ret_so = _driver->PasteInto(aStream.in(), theObjectID, so.in());
+  SALOMEDS::lock();
 
   return TCollection_AsciiString((char*)ret_so->GetID());
 }
@@ -232,7 +247,8 @@ unsigned char* SALOMEDS_Driver_i::DumpPython(const Handle(SALOMEDSImpl_Study)& t
 //                                          SALOMEDS_DriverFactory
 //###############################################################################################################
 
-SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType(const TCollection_AsciiString& theComponentType)
+SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType
+                     (const TCollection_AsciiString& theComponentType)
 {
   CORBA::Object_var obj;
 
@@ -240,14 +256,16 @@ SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType(const TCollection
   if (theComponentType == "SUPERV") aFactoryType = "SuperVisionContainer";
   else aFactoryType = "FactoryServer";
 
-  SALOMEDS::unlock();   
-  obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component(aFactoryType.ToCString(), 
-                                                                 theComponentType.ToCString());
-  
+  SALOMEDS::unlock();
+  obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component
+    (aFactoryType.ToCString(), theComponentType.ToCString());
+  SALOMEDS::lock();
+
   if (CORBA::is_nil(obj)) {
-    obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component("FactoryServerPy", theComponentType.ToCString());
+    obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component
+      ("FactoryServerPy", theComponentType.ToCString());
   }
-               
+
   if (!CORBA::is_nil(obj)) {
     SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
     return new SALOMEDS_Driver_i(aDriver, _orb);

diff --git a/src/SALOMEDS/SALOMEDS_GenericAttribute.cxx b/src/SALOMEDS/SALOMEDS_GenericAttribute.cxx
index ca66fdac64693e9a16412fb4d0a5f70f29f32f29..0e338f3b192a59a4b9f81f21544e618733966a74 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_GenericAttribute.cxx
+++ b/src/SALOMEDS/SALOMEDS_GenericAttribute.cxx
@@ -30,6 +30,7 @@
 #include "SALOMEDSImpl_SObject.hxx"
 #include "SALOMEDS_SObject.hxx"
 #include "SALOMEDS_ClientAttributes.hxx"
+#include "SALOMEDS.hxx"
 
 #ifdef WIN32
 #include <process.h>
@@ -77,7 +78,8 @@ SALOMEDS_GenericAttribute::~SALOMEDS_GenericAttribute()
 
 void SALOMEDS_GenericAttribute::CheckLocked() 
 {
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
       _local_impl->CheckLocked();
     }
@@ -93,7 +95,8 @@ void SALOMEDS_GenericAttribute::CheckLocked()
 std::string SALOMEDS_GenericAttribute::Type()
 {
   std::string aType;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     aType = _local_impl->Type().ToCString();
   }
   else {
@@ -105,7 +108,8 @@ std::string SALOMEDS_GenericAttribute::Type()
 std::string SALOMEDS_GenericAttribute::GetClassType()
 {
   std::string aType;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     aType = _local_impl->GetClassType().ToCString();
   }
   else {
@@ -117,7 +121,8 @@ std::string SALOMEDS_GenericAttribute::GetClassType()
 _PTR(SObject) SALOMEDS_GenericAttribute::GetSObject()
 {
   SALOMEDSClient_SObject* aSO = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     aSO = new SALOMEDS_SObject(_local_impl->GetSObject());
   }
   else {
@@ -128,12 +133,15 @@ _PTR(SObject) SALOMEDS_GenericAttribute::GetSObject()
 }
 
 
-SALOMEDS_GenericAttribute* SALOMEDS_GenericAttribute::CreateAttribute(const Handle(SALOMEDSImpl_GenericAttribute)& theGA)
+SALOMEDS_GenericAttribute* SALOMEDS_GenericAttribute::CreateAttribute
+                           (const Handle(SALOMEDSImpl_GenericAttribute)& theGA)
 {
+  SALOMEDS::Locker lock;
+
   SALOMEDS_GenericAttribute* aGA = NULL;
   std::string aTypeOfAttribute = theGA->GetClassType().ToCString();
   __CreateGenericClientAttributeLocal
-  return aGA;  
+  return aGA;
 }
 
 SALOMEDS_GenericAttribute* SALOMEDS_GenericAttribute::CreateAttribute(SALOMEDS::GenericAttribute_ptr theGA)
@@ -141,6 +149,5 @@ SALOMEDS_GenericAttribute* SALOMEDS_GenericAttribute::CreateAttribute(SALOMEDS::
   SALOMEDS_GenericAttribute* aGA = NULL;
   std::string aTypeOfAttribute = theGA->GetClassType();
   __CreateGenericClientAttributeCORBA
-  return aGA;  
+  return aGA;
 }
-

diff --git a/src/SALOMEDS/SALOMEDS_GenericAttribute_i.cxx b/src/SALOMEDS/SALOMEDS_GenericAttribute_i.cxx
index d4bd10e18f7f0c854b17456f711880f367c49be1..dcfc754948b8c23c9f4c4d8da241e7da7e719709 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_GenericAttribute_i.cxx
+++ b/src/SALOMEDS/SALOMEDS_GenericAttribute_i.cxx
@@ -92,17 +92,18 @@ char* SALOMEDS_GenericAttribute_i::GetClassType()
   if (!_impl.IsNull()) {
     return CORBA::string_dup(SALOMEDSImpl_GenericAttribute::Impl_GetClassType(_impl));
   }
-         
+
   return "";
-}  
+}
 
 
-SALOMEDS::GenericAttribute_ptr SALOMEDS_GenericAttribute_i::CreateAttribute(const Handle(TDF_Attribute)& theAttr,
-                                                                           CORBA::ORB_ptr theOrb) 
+SALOMEDS::GenericAttribute_ptr SALOMEDS_GenericAttribute_i::CreateAttribute
+                                        (const Handle(TDF_Attribute)& theAttr,
+                                         CORBA::ORB_ptr theOrb)
 {
-/*
   SALOMEDS::Locker lock;
-  
+
+/*
   static std::map<TDF_Attribute*, SALOMEDS_GenericAttribute_i*> _mapOfAttrib;
   SALOMEDS::GenericAttribute_var anAttribute;
   SALOMEDS_GenericAttribute_i* attr_servant = NULL;
@@ -118,13 +119,14 @@ SALOMEDS::GenericAttribute_ptr SALOMEDS_GenericAttribute_i::CreateAttribute(cons
   }
 */
   // mpv: now servants Destroyed by common algos of CORBA
-  char* aTypeOfAttribute = Handle(SALOMEDSImpl_GenericAttribute)::DownCast(theAttr)->GetClassType().ToCString();
+  char* aTypeOfAttribute = Handle(SALOMEDSImpl_GenericAttribute)::
+    DownCast(theAttr)->GetClassType().ToCString();
   SALOMEDS::GenericAttribute_var anAttribute;
   SALOMEDS_GenericAttribute_i* attr_servant = NULL;
   __CreateGenericCORBAAttribute
 
   return anAttribute._retn(); 
-}                                                                                                                    
+}
 
 //===========================================================================
 //   PRIVATE FUNCTIONS
@@ -135,7 +137,7 @@ long SALOMEDS_GenericAttribute_i::GetLocalImpl(const char* theHostname, CORBA::L
   long pid = (long)_getpid();
 #else
   long pid = (long)getpid();
-#endif  
+#endif
   isLocal = (strcmp(theHostname, GetHostname().c_str()) == 0 && pid == thePID)?1:0;
   TDF_Attribute* local_impl = _impl.operator->();
   return ((long)local_impl);

diff --git a/src/SALOMEDS/SALOMEDS_SComponent.cxx b/src/SALOMEDS/SALOMEDS_SComponent.cxx
index eaf98f1579d0228b38dbb1bf6be6e2e9681070b9..f061fcc5f9d08d7e26b9251a846541a8d15cac4a 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_SComponent.cxx
+++ b/src/SALOMEDS/SALOMEDS_SComponent.cxx
@@ -24,7 +24,10 @@
 
 
 #include "SALOMEDS_SComponent.hxx"
+
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SComponent_i.hxx"
+
 #include <string> 
 #include <TCollection_AsciiString.hxx> 
 
@@ -44,7 +47,8 @@ SALOMEDS_SComponent::~SALOMEDS_SComponent()
 std::string SALOMEDS_SComponent::ComponentDataType()
 {
   std::string aType;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     aType = (Handle(SALOMEDSImpl_SComponent)::DownCast(GetLocalImpl()))->ComponentDataType().ToCString();
   }
   else aType = (SALOMEDS::SComponent::_narrow(GetCORBAImpl()))->ComponentDataType();
@@ -55,7 +59,8 @@ std::string SALOMEDS_SComponent::ComponentDataType()
 bool SALOMEDS_SComponent::ComponentIOR(std::string& theID)
 {
   bool ret;
-  if(_isLocal) { 
+  if (_isLocal) { 
+    SALOMEDS::Locker lock;
     TCollection_AsciiString anIOR;
     ret = (Handle(SALOMEDSImpl_SComponent)::DownCast(GetLocalImpl()))->ComponentIOR(anIOR);
     theID = anIOR.ToCString();
@@ -71,10 +76,10 @@ bool SALOMEDS_SComponent::ComponentIOR(std::string& theID)
 
 SALOMEDS::SComponent_ptr SALOMEDS_SComponent::GetSComponent()
 {
-  if(_isLocal) {
-    if(!CORBA::is_nil(_corba_impl)) return SALOMEDS::SComponent::_narrow(GetCORBAImpl());
-    SALOMEDS::SComponent_var aSCO = SALOMEDS_SComponent_i::New(Handle(SALOMEDSImpl_SComponent)::DownCast(GetLocalImpl()),
-                                                              _orb);
+  if (_isLocal) {
+    if (!CORBA::is_nil(_corba_impl)) return SALOMEDS::SComponent::_narrow(GetCORBAImpl());
+    SALOMEDS::SComponent_var aSCO =
+      SALOMEDS_SComponent_i::New(Handle(SALOMEDSImpl_SComponent)::DownCast(GetLocalImpl()), _orb);
     return aSCO._retn();
   }
   else {
@@ -83,4 +88,3 @@ SALOMEDS::SComponent_ptr SALOMEDS_SComponent::GetSComponent()
 
   return SALOMEDS::SComponent::_nil();
 }
-

diff --git a/src/SALOMEDS/SALOMEDS_SComponentIterator.cxx b/src/SALOMEDS/SALOMEDS_SComponentIterator.cxx
index 73ab05039fdf4bda89251876f76803c626856731..56d6c94272b357d3e5188096a5b8603606f486fb 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_SComponentIterator.cxx
+++ b/src/SALOMEDS/SALOMEDS_SComponentIterator.cxx
@@ -22,8 +22,10 @@
 //  Module : SALOME
 
 #include "SALOMEDS_SComponentIterator.hxx"
-#include "SALOMEDSImpl_SComponent.hxx"
+
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SComponent.hxx"
+#include "SALOMEDSImpl_SComponent.hxx"
 
 SALOMEDS_SComponentIterator::SALOMEDS_SComponentIterator(const SALOMEDSImpl_SComponentIterator& theIterator)
 :_local_impl(theIterator)
@@ -45,28 +47,40 @@ SALOMEDS_SComponentIterator::~SALOMEDS_SComponentIterator()
 
 void SALOMEDS_SComponentIterator::Init()
 {
-  if(_isLocal) _local_impl.Init();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    _local_impl.Init();
+  }
   else _corba_impl->Init();
 }
 
 bool SALOMEDS_SComponentIterator::More()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl.More();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    ret = _local_impl.More();
+  }
   else ret = _corba_impl->More();
   return ret;
 }
- 
+
 void SALOMEDS_SComponentIterator::Next()
 {
-  if(_isLocal) _local_impl.Next();
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    _local_impl.Next();
+  }
   else _corba_impl->Next();
 }
- 
+
 _PTR(SComponent) SALOMEDS_SComponentIterator::Value()  
 {
   SALOMEDSClient_SComponent* aSCO = NULL;
-  if(_isLocal) aSCO = new SALOMEDS_SComponent(_local_impl.Value());
+  if (_isLocal) {
+    SALOMEDS::Locker lock; 
+    aSCO = new SALOMEDS_SComponent(_local_impl.Value());
+  }
   else aSCO = new SALOMEDS_SComponent(_corba_impl->Value());
   return _PTR(SComponent)(aSCO);
 }

diff --git a/src/SALOMEDS/SALOMEDS_SObject.cxx b/src/SALOMEDS/SALOMEDS_SObject.cxx
index eaf664e03cbd987f459c06f659255a7838005b5f..233c5fca805dfd5d790d5418ff401ff459a4dec8 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_SObject.cxx
+++ b/src/SALOMEDS/SALOMEDS_SObject.cxx
@@ -28,11 +28,14 @@
 #include <TColStd_HSequenceOfTransient.hxx>
 
 #include "SALOMEDS_SObject.hxx"
+
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SComponent.hxx"
-#include "SALOMEDSImpl_SComponent.hxx"
 #include "SALOMEDS_GenericAttribute.hxx"
-#include "SALOMEDSImpl_GenericAttribute.hxx"
 #include "SALOMEDS_Study.hxx"
+
+#include "SALOMEDSImpl_SComponent.hxx"
+#include "SALOMEDSImpl_GenericAttribute.hxx"
 #include "SALOMEDSImpl_Study.hxx"
 
 #include "Utils_ORB_INIT.hxx" 
@@ -90,15 +93,20 @@ SALOMEDS_SObject::~SALOMEDS_SObject()
 std::string SALOMEDS_SObject::GetID()
 {
   std::string aValue;
-  if(_isLocal) aValue = _local_impl->GetID().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aValue = _local_impl->GetID().ToCString();
+  }
   else aValue = _corba_impl->GetID();  
   return aValue;
 }
 
 _PTR(SComponent) SALOMEDS_SObject::GetFatherComponent()
 {
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_SComponent) aSCO = Handle(SALOMEDSImpl_SComponent)::DownCast(_local_impl->GetFatherComponent());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    Handle(SALOMEDSImpl_SComponent) aSCO =
+      Handle(SALOMEDSImpl_SComponent)::DownCast(_local_impl->GetFatherComponent());
     return _PTR(SComponent)(new SALOMEDS_SComponent(aSCO));
   }
   return _PTR(SComponent)(new SALOMEDS_SComponent(_corba_impl->GetFatherComponent()));
@@ -106,14 +114,19 @@ _PTR(SComponent) SALOMEDS_SObject::GetFatherComponent()
 
 _PTR(SObject) SALOMEDS_SObject::GetFather()
 {
-  if(_isLocal) return _PTR(SObject)(new SALOMEDS_SObject(_local_impl->GetFather()));
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    return _PTR(SObject)(new SALOMEDS_SObject(_local_impl->GetFather()));
+  }
   return _PTR(SObject)(new SALOMEDS_SObject(_corba_impl->GetFather()));
 }
 
-bool SALOMEDS_SObject::FindAttribute(_PTR(GenericAttribute)& anAttribute, const std::string& aTypeOfAttribute)
+bool SALOMEDS_SObject::FindAttribute(_PTR(GenericAttribute)& anAttribute,
+                                     const std::string& aTypeOfAttribute)
 {
   bool ret = false;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_GenericAttribute) anAttr;
     ret = _local_impl->FindAttribute(anAttr, (char*)aTypeOfAttribute.c_str());
     if(ret) anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(anAttr));
@@ -130,7 +143,8 @@ bool SALOMEDS_SObject::FindAttribute(_PTR(GenericAttribute)& anAttribute, const
 bool SALOMEDS_SObject::ReferencedObject(_PTR(SObject)& theObject)
 {
   bool ret = false;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_SObject) aSO;
     ret = _local_impl->ReferencedObject(aSO);
     if(ret) theObject = _PTR(SObject)(new SALOMEDS_SObject(aSO));
@@ -148,7 +162,8 @@ bool SALOMEDS_SObject::ReferencedObject(_PTR(SObject)& theObject)
 bool SALOMEDS_SObject::FindSubObject(int theTag, _PTR(SObject)& theObject)
 {
   bool ret = false;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(SALOMEDSImpl_SObject) aSO;
     ret = _local_impl->FindSubObject(theTag, aSO);
     if(ret) theObject = _PTR(SObject)(new SALOMEDS_SObject(aSO));
@@ -164,14 +179,20 @@ bool SALOMEDS_SObject::FindSubObject(int theTag, _PTR(SObject)& theObject)
 
 _PTR(Study) SALOMEDS_SObject::GetStudy()
 {
-  if(_isLocal) return _PTR(Study)(new SALOMEDS_Study(_local_impl->GetStudy()));
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    return _PTR(Study)(new SALOMEDS_Study(_local_impl->GetStudy()));
+  }
   return _PTR(Study)(new SALOMEDS_Study(_corba_impl->GetStudy()));
 }
 
 std::string SALOMEDS_SObject::Name()
 {
   std::string aName;
-  if(_isLocal) aName = _local_impl->Name().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aName = _local_impl->Name().ToCString();
+  }
   else aName = _corba_impl->Name();
 
   return aName;
@@ -179,7 +200,10 @@ std::string SALOMEDS_SObject::Name()
 
 void  SALOMEDS_SObject::Name(const std::string& theName)
 {
-  if(_isLocal) _local_impl->Name((char*)theName.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Name((char*)theName.c_str());
+  }
   else _corba_impl->Name(theName.c_str());
 }
 
@@ -189,18 +213,20 @@ vector<_PTR(GenericAttribute)> SALOMEDS_SObject::GetAllAttributes()
   int aLength = 0;
   SALOMEDSClient_GenericAttribute* anAttr;
 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     Handle(TColStd_HSequenceOfTransient) aSeq = _local_impl->GetAllAttributes();
     aLength = aSeq->Length();
-    for(int i = 1; i <= aLength; i++) {
-      anAttr = SALOMEDS_GenericAttribute::CreateAttribute(Handle(SALOMEDSImpl_GenericAttribute)::DownCast(aSeq->Value(i)));
+    for (int i = 1; i <= aLength; i++) {
+      anAttr = SALOMEDS_GenericAttribute::CreateAttribute
+        (Handle(SALOMEDSImpl_GenericAttribute)::DownCast(aSeq->Value(i)));
       aVector.push_back(_PTR(GenericAttribute)(anAttr));
     }
   }
   else {
     SALOMEDS::ListOfAttributes_var aSeq = _corba_impl->GetAllAttributes();
     aLength = aSeq->length();
-    for(int i = 0; i < aLength; i++) {
+    for (int i = 0; i < aLength; i++) {
       anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aSeq[i]);
       aVector.push_back(_PTR(GenericAttribute)(anAttr));
     }
@@ -212,7 +238,10 @@ vector<_PTR(GenericAttribute)> SALOMEDS_SObject::GetAllAttributes()
 std::string SALOMEDS_SObject::GetName()
 {
   std::string aName;
-  if(_isLocal) aName = _local_impl->GetName().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aName = _local_impl->GetName().ToCString();
+  }
   else aName = _corba_impl->GetName();
 
   return aName;
@@ -221,7 +250,10 @@ std::string SALOMEDS_SObject::GetName()
 std::string SALOMEDS_SObject::GetComment()
 {
   std::string aComment;
-  if(_isLocal) aComment = _local_impl->GetComment().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aComment = _local_impl->GetComment().ToCString();
+  }
   else aComment = _corba_impl->GetComment();
 
   return aComment;
@@ -230,7 +262,10 @@ std::string SALOMEDS_SObject::GetComment()
 std::string SALOMEDS_SObject::GetIOR()
 {
   std::string anIOR;
-  if(_isLocal) anIOR = _local_impl->GetIOR().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    anIOR = _local_impl->GetIOR().ToCString();
+  }
   else anIOR = _corba_impl->GetIOR();
 
   return anIOR;
@@ -238,20 +273,27 @@ std::string SALOMEDS_SObject::GetIOR()
 
 int SALOMEDS_SObject::Tag()
 {
-  if(_isLocal) return _local_impl->Tag();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    return _local_impl->Tag();
+  }
   return _corba_impl->Tag(); 
 }
 
 int SALOMEDS_SObject::Depth()
 {
-  if(_isLocal) return _local_impl->Depth();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    return _local_impl->Depth();
+  }
   return _corba_impl->Depth();  
 }
 
 CORBA::Object_ptr SALOMEDS_SObject::GetObject()
 {
   CORBA::Object_var obj;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     std::string anIOR = GetIOR();
     if (!anIOR.empty())
       obj = _orb->string_to_object(anIOR.c_str());

diff --git a/src/SALOMEDS/SALOMEDS_Study.cxx b/src/SALOMEDS/SALOMEDS_Study.cxx
index 1f6c1ee8719408dccad0baa76082c86b606cf111..17e3fcba0cdd81f819a9dd02112df47adf3fe8c0 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_Study.cxx
+++ b/src/SALOMEDS/SALOMEDS_Study.cxx
@@ -26,19 +26,22 @@
 #include "utilities.h" 
 
 #include "SALOMEDS_Study.hxx"
+
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SComponent.hxx"
-#include "SALOMEDSImpl_SComponent.hxx"
 #include "SALOMEDS_SObject.hxx"
-#include "SALOMEDSImpl_SObject.hxx"
 #include "SALOMEDS_StudyBuilder.hxx"
-#include "SALOMEDSImpl_StudyBuilder.hxx"
 #include "SALOMEDS_ChildIterator.hxx"
-#include "SALOMEDSImpl_ChildIterator.hxx"
 #include "SALOMEDS_SComponentIterator.hxx"
-#include "SALOMEDSImpl_SComponentIterator.hxx"
 #include "SALOMEDS_AttributeStudyProperties.hxx"
-#include "SALOMEDSImpl_AttributeStudyProperties.hxx"
 #include "SALOMEDS_UseCaseBuilder.hxx"
+
+#include "SALOMEDSImpl_SComponent.hxx"
+#include "SALOMEDSImpl_SObject.hxx"
+#include "SALOMEDSImpl_StudyBuilder.hxx"
+#include "SALOMEDSImpl_ChildIterator.hxx"
+#include "SALOMEDSImpl_SComponentIterator.hxx"
+#include "SALOMEDSImpl_AttributeStudyProperties.hxx"
 #include "SALOMEDSImpl_UseCaseBuilder.hxx"
 
 #include "SALOMEDS_Driver_i.hxx"
@@ -98,7 +101,10 @@ SALOMEDS_Study::~SALOMEDS_Study()
 std::string SALOMEDS_Study::GetPersistentReference()
 {
   std::string aRef;
-  if(_isLocal) aRef = _local_impl->GetPersistentReference().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aRef = _local_impl->GetPersistentReference().ToCString();
+  }
   else aRef = _corba_impl->GetPersistentReference();
   return aRef;
 }
@@ -106,7 +112,10 @@ std::string SALOMEDS_Study::GetPersistentReference()
 std::string SALOMEDS_Study::GetTransientReference()
 {
   std::string aRef;
-  if(_isLocal) aRef = _local_impl->GetTransientReference().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aRef = _local_impl->GetTransientReference().ToCString();
+  }
   else aRef = _corba_impl->GetTransientReference();
   return aRef;
 }
@@ -114,7 +123,10 @@ std::string SALOMEDS_Study::GetTransientReference()
 bool SALOMEDS_Study::IsEmpty()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->IsEmpty();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->IsEmpty();
+  }
   else ret = _corba_impl->IsEmpty();
   return ret;
 }
@@ -122,14 +134,17 @@ bool SALOMEDS_Study::IsEmpty()
 _PTR(SComponent) SALOMEDS_Study::FindComponent (const std::string& aComponentName)
 {
   SALOMEDSClient_SComponent* aSCO = NULL;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_SComponent) aSCO_impl =_local_impl->FindComponent((char*)aComponentName.c_str());
-    if(aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
+    Handle(SALOMEDSImpl_SComponent) aSCO_impl =
+      _local_impl->FindComponent((char*)aComponentName.c_str());
+    if (aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
     aSCO = new SALOMEDS_SComponent(aSCO_impl);
   }
   else {
     SALOMEDS::SComponent_var aSCO_impl = _corba_impl->FindComponent((char*)aComponentName.c_str());
-    if(CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
+    if (CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
     aSCO = new SALOMEDS_SComponent(aSCO_impl);
   }
   return _PTR(SComponent)(aSCO);
@@ -138,9 +153,12 @@ _PTR(SComponent) SALOMEDS_Study::FindComponent (const std::string& aComponentNam
 _PTR(SComponent) SALOMEDS_Study::FindComponentID(const std::string& aComponentID)
 {  
   SALOMEDSClient_SComponent* aSCO = NULL;
-  if(_isLocal) {
-    Handle(SALOMEDSImpl_SComponent) aSCO_impl =_local_impl->FindComponentID((char*)aComponentID.c_str());
-    if(aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
+    Handle(SALOMEDSImpl_SComponent) aSCO_impl =
+      _local_impl->FindComponentID((char*)aComponentID.c_str());
+    if (aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
     aSCO = new SALOMEDS_SComponent(aSCO_impl);
   }
   else {
@@ -149,57 +167,64 @@ _PTR(SComponent) SALOMEDS_Study::FindComponentID(const std::string& aComponentID
     aSCO = new SALOMEDS_SComponent(aSCO_impl);
   }
   return _PTR(SComponent)(aSCO);
-  
 }
  
 _PTR(SObject) SALOMEDS_Study::FindObject(const std::string& anObjectName)
 {
   SALOMEDSClient_SObject* aSO = NULL;
 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObject((char*)anObjectName.c_str());
-    if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
+    if (aSO_impl.IsNull()) return _PTR(SObject)(aSO);
     Handle(SALOMEDSImpl_SComponent) aSCO_impl = Handle(SALOMEDSImpl_SComponent)::DownCast(aSO_impl);
-    if(!aSCO_impl.IsNull()) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
+    if (!aSCO_impl.IsNull()) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
     aSO = new SALOMEDS_SObject(aSO_impl);
   }
   else { 
     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObject((char*)anObjectName.c_str());
-    if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
+    if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
     SALOMEDS::SComponent_var aSCO_impl = SALOMEDS::SComponent::_narrow(aSO_impl);
-    if(!CORBA::is_nil(aSCO_impl)) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
+    if (!CORBA::is_nil(aSCO_impl)) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
     aSO = new SALOMEDS_SObject(aSO_impl);
   }
 
   return _PTR(SObject)(aSO);
 }
- 
+
 std::vector<_PTR(SObject)> SALOMEDS_Study::FindObjectByName(const std::string& anObjectName, 
-                                                                     const std::string& aComponentName)   
+                                                            const std::string& aComponentName)   
 {
   std::vector<_PTR(SObject)> aVector;
   int i, aLength = 0;
-  
-  if(_isLocal) {
-    Handle(TColStd_HSequenceOfTransient) aSeq = _local_impl->FindObjectByName((char*)anObjectName.c_str(), (char*)aComponentName.c_str());
+
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
+    Handle(TColStd_HSequenceOfTransient) aSeq =
+      _local_impl->FindObjectByName((char*)anObjectName.c_str(), (char*)aComponentName.c_str());
     aLength = aSeq->Length();
-    for(i = 1; i<= aLength; i++) 
-      aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i)))));
+    for (i = 1; i<= aLength; i++) 
+      aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject
+                                      (Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i)))));
   }
   else {
     SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindObjectByName((char*)anObjectName.c_str(), 
                                                                            (char*)aComponentName.c_str());
     aLength = aSeq->length();
-    for(i = 0; i< aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
+    for (i = 0; i< aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
   }
 
   return aVector;
 }
- 
+
 _PTR(SObject) SALOMEDS_Study::FindObjectID(const std::string& anObjectID)
 {
   SALOMEDSClient_SObject* aSO = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObjectID((char*)anObjectID.c_str());
     if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
     return _PTR(SObject)(new SALOMEDS_SObject(aSO_impl));
@@ -215,22 +240,27 @@ _PTR(SObject) SALOMEDS_Study::FindObjectID(const std::string& anObjectID)
 _PTR(SObject) SALOMEDS_Study::CreateObjectID(const std::string& anObjectID)
 {
   SALOMEDSClient_SObject* aSO = NULL;
-  if(_isLocal) aSO = new SALOMEDS_SObject(_local_impl->CreateObjectID((char*)anObjectID.c_str()));
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aSO = new SALOMEDS_SObject(_local_impl->CreateObjectID((char*)anObjectID.c_str()));
+  }
   else aSO = new SALOMEDS_SObject(_corba_impl->CreateObjectID((char*)anObjectID.c_str())); 
   return _PTR(SObject)(aSO);
 }
- 
+
 _PTR(SObject) SALOMEDS_Study::FindObjectIOR(const std::string& anObjectIOR)
 {
   SALOMEDSClient_SObject* aSO = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObjectIOR((char*)anObjectIOR.c_str());
-    if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
+    if (aSO_impl.IsNull()) return _PTR(SObject)(aSO);
     aSO = new SALOMEDS_SObject(aSO_impl);
   }
   else { 
     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectIOR((char*)anObjectIOR.c_str());
-    if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
+    if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
     aSO = new SALOMEDS_SObject(aSO_impl);
   }
   return _PTR(SObject)(aSO);
@@ -239,14 +269,16 @@ _PTR(SObject) SALOMEDS_Study::FindObjectIOR(const std::string& anObjectIOR)
 _PTR(SObject) SALOMEDS_Study::FindObjectByPath(const std::string& thePath)
 {
   SALOMEDSClient_SObject* aSO = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObjectByPath((char*)thePath.c_str());
-    if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
+    if (aSO_impl.IsNull()) return _PTR(SObject)(aSO);
     aSO = new SALOMEDS_SObject(aSO_impl);
   }
   else {
     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectByPath((char*)thePath.c_str());
-    if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
+    if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
     aSO = new SALOMEDS_SObject(aSO_impl);
   }
   return _PTR(SObject)(aSO);
@@ -256,21 +288,30 @@ std::string SALOMEDS_Study::GetObjectPath(const _PTR(SObject)& theSO)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   std::string aPath;
-  if(_isLocal) aPath = _local_impl->GetObjectPath(aSO->GetLocalImpl()).ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aPath = _local_impl->GetObjectPath(aSO->GetLocalImpl()).ToCString();
+  }
   else aPath = _corba_impl->GetObjectPath(aSO->GetCORBAImpl());
   return aPath;
 }
 
 void SALOMEDS_Study::SetContext(const std::string& thePath)
 {
-  if(_isLocal) _local_impl->SetContext((char*)thePath.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->SetContext((char*)thePath.c_str());
+  }
   else _corba_impl->SetContext((char*)thePath.c_str());
 }
 
 std::string SALOMEDS_Study::GetContext()  
 {
   std::string aPath;
-  if(_isLocal) aPath = _local_impl->GetContext().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aPath = _local_impl->GetContext().ToCString();
+  }
   else aPath = _corba_impl->GetContext();
   return aPath;
 }
@@ -279,15 +320,17 @@ std::vector<std::string> SALOMEDS_Study::GetObjectNames(const std::string& theCo
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetObjectNames((char*)theContext.c_str());
     aLength = aSeq->Length();
-    for(i = 1; i<=aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
   }
   else {
     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetObjectNames((char*)theContext.c_str());
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back(std::string((std::string)aSeq[i].in()));
+    for (i = 0; i < aLength; i++) aVector.push_back(std::string((std::string)aSeq[i].in()));
   }
   return aVector;
 }
@@ -296,15 +339,18 @@ std::vector<std::string> SALOMEDS_Study::GetDirectoryNames(const std::string& th
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
-    Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetDirectoryNames((char*)theContext.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
+    Handle(TColStd_HSequenceOfAsciiString) aSeq =
+      _local_impl->GetDirectoryNames((char*)theContext.c_str());
     aLength = aSeq->Length();
-    for(i = 1; i<=aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
   }
   else {
     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetDirectoryNames((char*)theContext.c_str());
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
@@ -313,16 +359,18 @@ std::vector<std::string> SALOMEDS_Study::GetFileNames(const std::string& theCont
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetFileNames((char*)theContext.c_str());
     aLength = aSeq->Length();
-    for(i = 1; i<=aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
   }
   else {
     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetFileNames((char*)theContext.c_str());
     aLength = aSeq->length();
 
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
@@ -331,15 +379,17 @@ std::vector<std::string> SALOMEDS_Study::GetComponentNames(const std::string& th
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetComponentNames((char*)theContext.c_str());
     aLength = aSeq->Length();
-    for(i = 1; i<=aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
   }
   else {
     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetComponentNames((char*)theContext.c_str());
     aLength = aSeq->length();
-    for(i = 0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
@@ -348,7 +398,9 @@ _PTR(ChildIterator) SALOMEDS_Study::NewChildIterator(const _PTR(SObject)& theSO)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   SALOMEDSClient_ChildIterator* aCI = NULL; 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_ChildIterator) aCIimpl = _local_impl->NewChildIterator(aSO->GetLocalImpl());
     aCI = new SALOMEDS_ChildIterator(aCIimpl);
   }
@@ -363,7 +415,9 @@ _PTR(ChildIterator) SALOMEDS_Study::NewChildIterator(const _PTR(SObject)& theSO)
 _PTR(SComponentIterator) SALOMEDS_Study::NewComponentIterator()
 {
   SALOMEDSClient_SComponentIterator* aCI = NULL; 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     SALOMEDSImpl_SComponentIterator aCIimpl = _local_impl->NewComponentIterator();
     aCI = new SALOMEDS_SComponentIterator(aCIimpl);
   }
@@ -374,11 +428,13 @@ _PTR(SComponentIterator) SALOMEDS_Study::NewComponentIterator()
 
   return _PTR(SComponentIterator)(aCI);
 }
- 
+
 _PTR(StudyBuilder) SALOMEDS_Study::NewBuilder()
 {
   SALOMEDSClient_StudyBuilder* aSB = NULL; 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_StudyBuilder) aSBimpl = _local_impl->NewBuilder();
     aSB = new SALOMEDS_StudyBuilder(aSBimpl);
   }
@@ -393,35 +449,50 @@ _PTR(StudyBuilder) SALOMEDS_Study::NewBuilder()
 std::string SALOMEDS_Study::Name()
 {
   std::string aName;
-  if(_isLocal) aName = _local_impl->Name().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aName = _local_impl->Name().ToCString();
+  }
   else aName = _corba_impl->Name();
   return aName;
 }
- 
+
 void SALOMEDS_Study::Name(const std::string& theName)
 {
-  if(_isLocal) _local_impl->Name((char*)theName.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Name((char*)theName.c_str());
+  }
   else _corba_impl->Name((char*)theName.c_str());
 }
 
 bool SALOMEDS_Study::IsSaved()
 {
   bool isSaved;
-  if(_isLocal) isSaved = _local_impl->IsSaved();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    isSaved = _local_impl->IsSaved();
+  }
   else isSaved = _corba_impl->IsSaved();
   return isSaved;
 }
 
 void SALOMEDS_Study::IsSaved(bool save)
 {
-  if(_isLocal) _local_impl->IsSaved(save);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->IsSaved(save);
+  }
   else _corba_impl->IsSaved(save);
 }
 
 bool SALOMEDS_Study::IsModified()
 {
   bool isModified;
-  if(_isLocal) isModified = _local_impl->IsModified();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    isModified = _local_impl->IsModified();
+  }
   else isModified = _corba_impl->IsModified();
   return isModified;
 }
@@ -429,28 +500,40 @@ bool SALOMEDS_Study::IsModified()
 std::string SALOMEDS_Study::URL()
 {
   std::string aURL;
-  if(_isLocal) aURL = _local_impl->URL().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aURL = _local_impl->URL().ToCString();
+  }
   else aURL = _corba_impl->URL();
   return aURL;
 }
 
 void SALOMEDS_Study::URL(const std::string& url)
 {
-  if(_isLocal) _local_impl->URL((char*)url.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->URL((char*)url.c_str());
+  }
   else _corba_impl->URL((char*)url.c_str());
 }
 
 int SALOMEDS_Study::StudyId()
 {
   int anID;
-  if(_isLocal) anID = _local_impl->StudyId();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    anID = _local_impl->StudyId();
+  }
   else anID = _corba_impl->StudyId();
   return anID;
 }
  
 void SALOMEDS_Study::StudyId(int id) 
 {
-  if(_isLocal) _local_impl->StudyId(id);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->StudyId(id);
+  }
   else _corba_impl->StudyId(id);  
 }
 
@@ -459,12 +542,13 @@ std::vector<_PTR(SObject)> SALOMEDS_Study::FindDependances(const _PTR(SObject)&
   std::vector<_PTR(SObject)> aVector;
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(TColStd_HSequenceOfTransient) aSeq = _local_impl->FindDependances(aSO->GetLocalImpl());
-    if ( !aSeq.IsNull() )
-    {
+    if (!aSeq.IsNull()) {
       aLength = aSeq->Length();
-      for(i=1; i<=aLength; i++) 
+      for (i = 1; i <= aLength; i++) 
         aVector.push_back(_PTR(SObject)(
           new SALOMEDS_SObject(Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i)))));
     }
@@ -472,7 +556,7 @@ std::vector<_PTR(SObject)> SALOMEDS_Study::FindDependances(const _PTR(SObject)&
   else {
     SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindDependances(aSO->GetCORBAImpl());
     aLength = aSeq->length();
-    for(i=0; i<aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
+    for (i = 0; i < aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
   }
   return aVector;
 }
@@ -480,7 +564,10 @@ std::vector<_PTR(SObject)> SALOMEDS_Study::FindDependances(const _PTR(SObject)&
 _PTR(AttributeStudyProperties) SALOMEDS_Study::GetProperties()
 {
   SALOMEDSClient_AttributeStudyProperties* aProp;
-  if(_isLocal) aProp = new SALOMEDS_AttributeStudyProperties(_local_impl->GetProperties());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aProp = new SALOMEDS_AttributeStudyProperties(_local_impl->GetProperties());
+  }
   else aProp = new SALOMEDS_AttributeStudyProperties(_corba_impl->GetProperties());
   return _PTR(AttributeStudyProperties)(aProp);
 }
@@ -488,7 +575,10 @@ _PTR(AttributeStudyProperties) SALOMEDS_Study::GetProperties()
 std::string SALOMEDS_Study::GetLastModificationDate() 
 {
   std::string aDate;
-  if(_isLocal) aDate = _local_impl->GetLastModificationDate().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aDate = _local_impl->GetLastModificationDate().ToCString();
+  }
   else aDate = _corba_impl->GetLastModificationDate();
   return aDate;
 }
@@ -497,15 +587,17 @@ std::vector<std::string> SALOMEDS_Study::GetModificationsDate()
 {
   std::vector<std::string> aVector;
   int aLength, i;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetModificationsDate();
     aLength = aSeq->Length();
-    for(i=1; i<=aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
+    for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
   }
   else {
     SALOMEDS::ListOfDates_var aSeq = _corba_impl->GetModificationsDate();
     aLength = aSeq->length();
-    for(i=0; i<aLength; i++) aVector.push_back((char*)aSeq[i].in());
+    for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
   }
   return aVector;
 }
@@ -513,7 +605,9 @@ std::vector<std::string> SALOMEDS_Study::GetModificationsDate()
 _PTR(UseCaseBuilder) SALOMEDS_Study::GetUseCaseBuilder()
 {
   SALOMEDSClient_UseCaseBuilder* aUB = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_UseCaseBuilder) aUBimpl = _local_impl->GetUseCaseBuilder();
     aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
   }
@@ -527,7 +621,10 @@ _PTR(UseCaseBuilder) SALOMEDS_Study::GetUseCaseBuilder()
 
 void SALOMEDS_Study::Close()
 {
-  if(_isLocal) _local_impl->Close();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Close();
+  }
   else _corba_impl->Close();
 }
 
@@ -539,13 +636,8 @@ void SALOMEDS_Study::EnableUseCaseAutoFilling(bool isEnabled)
 
 bool SALOMEDS_Study::DumpStudy(const std::string& thePath, const std::string& theBaseName, bool isPublished)
 {
-  bool ret;
-  if(_isLocal) {
-    SALOMEDS_DriverFactory_i* aFactory = new SALOMEDS_DriverFactory_i(_orb);
-    ret = _local_impl->DumpStudy((char*)thePath.c_str(), (char*)theBaseName.c_str(), isPublished, aFactory);
-    delete aFactory;
-  }
-  else ret = _corba_impl->DumpStudy((char*)thePath.c_str(), (char*)theBaseName.c_str(), isPublished);
+  //SRN: Pure CORBA DumpStudy as it does more cleaning than the local one
+  bool ret = _corba_impl->DumpStudy((char*)thePath.c_str(), (char*)theBaseName.c_str(), isPublished);
   return ret;
 }     
 
@@ -568,11 +660,13 @@ void SALOMEDS_Study::init_orb()
 
 SALOMEDS::Study_ptr SALOMEDS_Study::GetStudy()
 {
-  if(_isLocal) {
-    if(!CORBA::is_nil(_corba_impl)) return _corba_impl;
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
+    if (!CORBA::is_nil(_corba_impl)) return _corba_impl;
     std::string anIOR = _local_impl->GetTransientReference().ToCString();
     SALOMEDS::Study_var aStudy;
-    if(!_local_impl->IsError() && anIOR != "") {
+    if (!_local_impl->IsError() && anIOR != "") {
       aStudy = SALOMEDS::Study::_narrow(_orb->string_to_object(anIOR.c_str()));
     }
     else {
@@ -585,6 +679,6 @@ SALOMEDS::Study_ptr SALOMEDS_Study::GetStudy()
   else {
     return _corba_impl;
   }
-   
+
   return SALOMEDS::Study::_nil();
 }

diff --git a/src/SALOMEDS/SALOMEDS_StudyBuilder.cxx b/src/SALOMEDS/SALOMEDS_StudyBuilder.cxx
index 045fdea8d99fd2bc2d5f7ab606a4d462552d3fd1..e11a77eb498a0d41f83270d5780b8aa81766eacd 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_StudyBuilder.cxx
+++ b/src/SALOMEDS/SALOMEDS_StudyBuilder.cxx
@@ -26,17 +26,23 @@
 #include "utilities.h"
 
 #include "SALOMEDS_StudyBuilder.hxx"
+
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SObject.hxx"
-#include "SALOMEDSImpl_SObject.hxx"
 #include "SALOMEDS_SComponent.hxx"
-#include "SALOMEDSImpl_SComponent.hxx"
-#include "SALOMEDS_Driver_i.hxx"
 #include "SALOMEDS_GenericAttribute.hxx"
+#include "SALOMEDS_StudyManager.hxx"
+
+#include "SALOMEDS_Driver_i.hxx"
+
+#include "SALOMEDSImpl_SObject.hxx"
+#include "SALOMEDSImpl_SComponent.hxx"
 #include "SALOMEDSImpl_GenericAttribute.hxx"
+
 #include <string>
+
 #include <TCollection_AsciiString.hxx> 
 #include <TDF_Attribute.hxx>
-#include "SALOMEDS_StudyManager.hxx"
 
 #include "Utils_CorbaException.hxx"
 #include "Utils_ORB_INIT.hxx" 
@@ -68,11 +74,12 @@ SALOMEDS_StudyBuilder::~SALOMEDS_StudyBuilder()
 
 _PTR(SComponent) SALOMEDS_StudyBuilder::NewComponent(const std::string& ComponentDataType)
 {
-  CheckLocked();
-
   SALOMEDSClient_SComponent* aSCO = NULL;
-  
-  if(_isLocal) {
+
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SComponent) aSCO_impl =_local_impl->NewComponent((char*)ComponentDataType.c_str());
     if(aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
     aSCO = new SALOMEDS_SComponent(aSCO_impl);
@@ -82,18 +89,21 @@ _PTR(SComponent) SALOMEDS_StudyBuilder::NewComponent(const std::string& Componen
     if(CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
     aSCO = new SALOMEDS_SComponent(aSCO_impl);
   }
- 
+
   return _PTR(SComponent)(aSCO);
 }
 
 void SALOMEDS_StudyBuilder::DefineComponentInstance (const _PTR(SComponent)& theSCO, 
                                                     const std::string& ComponentIOR)
 {
-  CheckLocked();
-
   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
-  if(_isLocal) _local_impl->DefineComponentInstance(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()),
-                                                    (char*)ComponentIOR.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->DefineComponentInstance(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()),
+                                         (char*)ComponentIOR.c_str());
+  }
   else {
     CORBA::Object_var obj = _orb->string_to_object(ComponentIOR.c_str());
     _corba_impl->DefineComponentInstance(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()), obj);
@@ -102,10 +112,13 @@ void SALOMEDS_StudyBuilder::DefineComponentInstance (const _PTR(SComponent)& the
 
 void SALOMEDS_StudyBuilder::RemoveComponent(const _PTR(SComponent)& theSCO)
 {
-  CheckLocked();
-
   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
-  if(_isLocal) _local_impl->RemoveComponent(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()));
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->RemoveComponent(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()));
+  }
   else _corba_impl->RemoveComponent(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()));
 }
 
@@ -115,8 +128,10 @@ _PTR(SObject) SALOMEDS_StudyBuilder::NewObject(const _PTR(SObject)& theFatherObj
 
   SALOMEDSClient_SObject* aSO = NULL;
   SALOMEDS_SObject* father = dynamic_cast< SALOMEDS_SObject*>(theFatherObject.get());
-  if(father == NULL) return _PTR(SObject)(aSO);
-  if(_isLocal) {
+  if (father == NULL) return _PTR(SObject)(aSO);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->NewObject(father->GetLocalImpl());
     if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
     aSO = new SALOMEDS_SObject(aSO_impl);
@@ -136,8 +151,10 @@ _PTR(SObject) SALOMEDS_StudyBuilder::NewObjectToTag(const _PTR(SObject)& theFath
 
   SALOMEDSClient_SObject* aSO = NULL;
   SALOMEDS_SObject* father = dynamic_cast< SALOMEDS_SObject*>(theFatherObject.get());
-  if(father == NULL) return _PTR(SObject)(aSO);
-  if(_isLocal) {
+  if (father == NULL) return _PTR(SObject)(aSO);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->NewObjectToTag(father->GetLocalImpl(), theTag);
     if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
     aSO = new SALOMEDS_SObject(aSO_impl);
@@ -149,20 +166,20 @@ _PTR(SObject) SALOMEDS_StudyBuilder::NewObjectToTag(const _PTR(SObject)& theFath
   }
 
   return _PTR(SObject)(aSO);
-  
 }
 
 void SALOMEDS_StudyBuilder::AddDirectory(const std::string& thePath)
 {
-  CheckLocked();
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
 
-  if(_isLocal) {
     _local_impl->AddDirectory((char*)thePath.c_str());
-    if(_local_impl->IsError()) {
+    if (_local_impl->IsError()) {
       std::string anErrorCode = _local_impl->GetErrorCode().ToCString();
-      if(anErrorCode == "StudyNameAlreadyUsed") throw SALOMEDS::Study::StudyNameAlreadyUsed(); 
-      if(anErrorCode == "StudyInvalidDirectory") throw SALOMEDS::Study::StudyInvalidDirectory(); 
-      if(anErrorCode == "StudyInvalidComponent") throw SALOMEDS::Study::StudyInvalidComponent();  
+      if (anErrorCode == "StudyNameAlreadyUsed")  throw SALOMEDS::Study::StudyNameAlreadyUsed(); 
+      if (anErrorCode == "StudyInvalidDirectory") throw SALOMEDS::Study::StudyInvalidDirectory(); 
+      if (anErrorCode == "StudyInvalidComponent") throw SALOMEDS::Study::StudyInvalidComponent();  
     }
   }
   else _corba_impl->AddDirectory((char*)thePath.c_str());
@@ -174,9 +191,12 @@ void SALOMEDS_StudyBuilder::LoadWith(const _PTR(SComponent)& theSCO, const std::
   CORBA::Object_var obj = _orb->string_to_object(theIOR.c_str());
   SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
   
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     SALOMEDS_Driver_i* drv = new SALOMEDS_Driver_i(aDriver, _orb);    
-    Handle(SALOMEDSImpl_SComponent) aSCO_impl = Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl());
+    Handle(SALOMEDSImpl_SComponent) aSCO_impl =
+      Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl());
     bool isDone = _local_impl->LoadWith(aSCO_impl, drv);
     delete drv;
     if(!isDone && _local_impl->IsError()) 
@@ -190,46 +210,55 @@ void SALOMEDS_StudyBuilder::LoadWith(const _PTR(SComponent)& theSCO, const std::
 void SALOMEDS_StudyBuilder::Load(const _PTR(SObject)& theSCO)
 {
   SALOMEDS_SComponent* aSCO = dynamic_cast<SALOMEDS_SComponent*>(theSCO.get());
-  if(_isLocal) _local_impl->Load(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()));
+  if (_isLocal) _local_impl->Load(Handle(SALOMEDSImpl_SComponent)::DownCast(aSCO->GetLocalImpl()));
   else _corba_impl->Load(SALOMEDS::SComponent::_narrow(aSCO->GetCORBAImpl()));
 }
 
 void SALOMEDS_StudyBuilder::RemoveObject(const _PTR(SObject)& theSO)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->RemoveObject(aSO->GetLocalImpl());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->RemoveObject(aSO->GetLocalImpl());
+  }
   else _corba_impl->RemoveObject(aSO->GetCORBAImpl());
 }
 
 void SALOMEDS_StudyBuilder::RemoveObjectWithChildren(const _PTR(SObject)& theSO)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->RemoveObjectWithChildren(aSO->GetLocalImpl());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->RemoveObjectWithChildren(aSO->GetLocalImpl());
+  }
   else _corba_impl->RemoveObjectWithChildren(aSO->GetCORBAImpl());
 }
- 
+
 _PTR(GenericAttribute) SALOMEDS_StudyBuilder::FindOrCreateAttribute(const _PTR(SObject)& theSO, 
                                                                    const std::string& aTypeOfAttribute)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   SALOMEDSClient_GenericAttribute* anAttr = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_GenericAttribute) aGA;
     try {
-      aGA=Handle(SALOMEDSImpl_GenericAttribute)::DownCast(_local_impl->FindOrCreateAttribute(aSO->GetLocalImpl(),
-                                                                                             (char*)aTypeOfAttribute.c_str()));
-     }
+      aGA = Handle(SALOMEDSImpl_GenericAttribute)::DownCast
+        (_local_impl->FindOrCreateAttribute(aSO->GetLocalImpl(), (char*)aTypeOfAttribute.c_str()));
+    }
     catch (...) {
       throw SALOMEDS::StudyBuilder::LockProtection();
-    }  
+    }
     anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aGA);
   }
   else {
-    SALOMEDS::GenericAttribute_var aGA = _corba_impl->FindOrCreateAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
+    SALOMEDS::GenericAttribute_var aGA =
+      _corba_impl->FindOrCreateAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
     anAttr = SALOMEDS_GenericAttribute::CreateAttribute(aGA);
   }
 
@@ -242,7 +271,9 @@ bool SALOMEDS_StudyBuilder::FindAttribute(const _PTR(SObject)& theSO,
 {
   bool ret;
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_GenericAttribute) aGA;
     ret = _local_impl->FindAttribute(aSO->GetLocalImpl(), aGA, (char*)aTypeOfAttribute.c_str());
     if(ret) anAttribute = _PTR(GenericAttribute)(SALOMEDS_GenericAttribute::CreateAttribute(aGA));
@@ -255,41 +286,53 @@ bool SALOMEDS_StudyBuilder::FindAttribute(const _PTR(SObject)& theSO,
 
   return ret;
 }
- 
+
 void SALOMEDS_StudyBuilder::RemoveAttribute(const _PTR(SObject)& theSO, const std::string& aTypeOfAttribute)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->RemoveAttribute(aSO->GetLocalImpl(), (char*)aTypeOfAttribute.c_str());
-  else _corba_impl->RemoveAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str()); 
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->RemoveAttribute(aSO->GetLocalImpl(), (char*)aTypeOfAttribute.c_str());
+  }
+  else _corba_impl->RemoveAttribute(aSO->GetCORBAImpl(), (char*)aTypeOfAttribute.c_str());
 }
 
 void SALOMEDS_StudyBuilder::Addreference(const _PTR(SObject)& me, const _PTR(SObject)& thereferencedObject)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(me.get());
   SALOMEDS_SObject* aRefSO = dynamic_cast<SALOMEDS_SObject*>(thereferencedObject.get());
-  if(_isLocal) _local_impl->Addreference(aSO->GetLocalImpl(), aRefSO->GetLocalImpl());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->Addreference(aSO->GetLocalImpl(), aRefSO->GetLocalImpl());
+  }
   else _corba_impl->Addreference(aSO->GetCORBAImpl(), aRefSO->GetCORBAImpl());
 }
 
 void SALOMEDS_StudyBuilder::RemoveReference(const _PTR(SObject)& me)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(me.get());
-  if(_isLocal) _local_impl->RemoveReference(aSO->GetLocalImpl());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->RemoveReference(aSO->GetLocalImpl());
+  }
   else _corba_impl->RemoveReference(aSO->GetCORBAImpl());
 }
 
 void SALOMEDS_StudyBuilder::SetGUID(const _PTR(SObject)& theSO, const std::string& theGUID)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->SetGUID(aSO->GetLocalImpl(), (char*)theGUID.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->SetGUID(aSO->GetLocalImpl(), (char*)theGUID.c_str());
+  }
   else _corba_impl->SetGUID(aSO->GetCORBAImpl(), (char*)theGUID.c_str());
 }
  
@@ -297,7 +340,11 @@ bool SALOMEDS_StudyBuilder::IsGUID(const _PTR(SObject)& theSO, const std::string
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   bool ret;
-  if(_isLocal) ret = _local_impl->IsGUID(aSO->GetLocalImpl(), (char*)theGUID.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
+    ret = _local_impl->IsGUID(aSO->GetLocalImpl(), (char*)theGUID.c_str());
+  }
   else ret = _corba_impl->IsGUID(aSO->GetCORBAImpl(), (char*)theGUID.c_str());
 
   return ret;
@@ -305,13 +352,17 @@ bool SALOMEDS_StudyBuilder::IsGUID(const _PTR(SObject)& theSO, const std::string
 
 void SALOMEDS_StudyBuilder::NewCommand()
 {
-  if(_isLocal) _local_impl->NewCommand();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->NewCommand();
+  }
   else _corba_impl->NewCommand();
 }
  
 void SALOMEDS_StudyBuilder::CommitCommand()
 {
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
       _local_impl->CommitCommand();
     }
@@ -325,20 +376,27 @@ void SALOMEDS_StudyBuilder::CommitCommand()
 bool SALOMEDS_StudyBuilder::HasOpenCommand()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->HasOpenCommand();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->HasOpenCommand();
+  }
   else ret = _corba_impl->HasOpenCommand();
   return ret;
 }
 
 void SALOMEDS_StudyBuilder::AbortCommand()
 {
-  if(_isLocal) _local_impl->AbortCommand();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->AbortCommand();
+  }
   else _corba_impl->AbortCommand();
 }
 
 void SALOMEDS_StudyBuilder::Undo()
 {
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
       _local_impl->Undo();
     }
@@ -348,10 +406,11 @@ void SALOMEDS_StudyBuilder::Undo()
   }
   else _corba_impl->Undo();
 }
- 
+
 void SALOMEDS_StudyBuilder::Redo()
 {
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
       _local_impl->Redo();
     }
@@ -361,11 +420,14 @@ void SALOMEDS_StudyBuilder::Redo()
   }
   else _corba_impl->Redo(); 
 }
- 
+
 bool SALOMEDS_StudyBuilder::GetAvailableUndos()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->GetAvailableUndos();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->GetAvailableUndos();
+  }
   else ret = _corba_impl->GetAvailableUndos();
   return ret;
 }
@@ -373,7 +435,10 @@ bool SALOMEDS_StudyBuilder::GetAvailableUndos()
 bool SALOMEDS_StudyBuilder::GetAvailableRedos()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->GetAvailableRedos();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->GetAvailableRedos();
+  }
   else ret = _corba_impl->GetAvailableRedos();
   return ret; 
 }
@@ -381,23 +446,30 @@ bool SALOMEDS_StudyBuilder::GetAvailableRedos()
 int SALOMEDS_StudyBuilder::UndoLimit()
 {
   int aLimit;
-  if(_isLocal) aLimit = _local_impl->UndoLimit();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aLimit = _local_impl->UndoLimit();
+  }
   else aLimit = _corba_impl->UndoLimit();
   return aLimit;
 }
  
 void SALOMEDS_StudyBuilder::UndoLimit(int theLimit)
 {
-  CheckLocked();
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
 
-  if(_isLocal) _local_impl->UndoLimit(theLimit);
+    _local_impl->UndoLimit(theLimit);
+  }
   else _corba_impl->UndoLimit(theLimit);
 }
  
 void SALOMEDS_StudyBuilder::CheckLocked()
 {
   //There is only local part as CORBA part throws the correct exeception
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
     try {
       _local_impl->CheckLocked();
     }
@@ -409,34 +481,43 @@ void SALOMEDS_StudyBuilder::CheckLocked()
 
 void SALOMEDS_StudyBuilder::SetName(const _PTR(SObject)& theSO, const std::string& theValue)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->SetName(aSO->GetLocalImpl(), (char*)theValue.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->SetName(aSO->GetLocalImpl(), (char*)theValue.c_str());
+  }
   else _corba_impl->SetName(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 }
 
 void SALOMEDS_StudyBuilder::SetComment(const _PTR(SObject)& theSO, const std::string& theValue)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->SetComment(aSO->GetLocalImpl(), (char*)theValue.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->SetComment(aSO->GetLocalImpl(), (char*)theValue.c_str());
+  }
   else _corba_impl->SetComment(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 }
 
 void SALOMEDS_StudyBuilder::SetIOR(const _PTR(SObject)& theSO, const std::string& theValue)
 {
-  CheckLocked();
-
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
-  if(_isLocal) _local_impl->SetIOR(aSO->GetLocalImpl(), (char*)theValue.c_str());
+  if (_isLocal) {
+    CheckLocked();
+    SALOMEDS::Locker lock;
+
+    _local_impl->SetIOR(aSO->GetLocalImpl(), (char*)theValue.c_str());
+  }
   else _corba_impl->SetIOR(aSO->GetCORBAImpl(), (char*)theValue.c_str());
 }
 
 void SALOMEDS_StudyBuilder::init_orb()
 {
-  ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
+  ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting()); 
-  _orb = init(0 , 0 ) ;     
+  _orb = init(0 , 0 );     
 }

diff --git a/src/SALOMEDS/SALOMEDS_StudyManager.cxx b/src/SALOMEDS/SALOMEDS_StudyManager.cxx
index ec0137fb2397f9f2dd3e0764652f23238ed6f721..17e273f0e1ee937129c088162963ffa635deb73a 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_StudyManager.cxx
+++ b/src/SALOMEDS/SALOMEDS_StudyManager.cxx
@@ -24,11 +24,14 @@
 
 #include "SALOMEDS_StudyManager.hxx"
 
-#include "SALOMEDSImpl_Study.hxx"
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_Study.hxx"
 #include "SALOMEDS_SObject.hxx"
+
 #include "SALOMEDS_Driver_i.hxx"
 
+#include "SALOMEDSImpl_Study.hxx"
+
 #include "Utils_ORB_INIT.hxx" 
 #include "Utils_SINGLETON.hxx" 
 
@@ -45,7 +48,7 @@
 
 #include "OpUtil.hxx"
 
-using namespace std; 
+using namespace std;
 
 SALOMEDS_Driver_i* GetDriver(const Handle(SALOMEDSImpl_SObject)& theObject, CORBA::ORB_ptr orb);
 
@@ -107,7 +110,7 @@ _PTR(Study) SALOMEDS_StudyManager::NewStudy(const std::string& study_name)
   SALOMEDSClient_Study* aStudy = NULL;
 
   SALOMEDS::Study_var aStudy_impl = _corba_impl->NewStudy((char*)study_name.c_str());
-  if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy); 
+  if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy);
   aStudy = new SALOMEDS_Study(aStudy_impl);
 
   return _PTR(Study)(aStudy);
@@ -119,7 +122,7 @@ _PTR(Study) SALOMEDS_StudyManager::Open(const std::string& theStudyUrl)
   SALOMEDSClient_Study* aStudy = NULL;
 
   SALOMEDS::Study_var aStudy_impl = _corba_impl->Open((char*)theStudyUrl.c_str());
-  if(CORBA::is_nil(aStudy_impl)) return  _PTR(Study)(aStudy); 
+  if(CORBA::is_nil(aStudy_impl)) return  _PTR(Study)(aStudy);
     
   aStudy = new SALOMEDS_Study(aStudy_impl.in());
 
@@ -166,7 +169,9 @@ std::vector<std::string> SALOMEDS_StudyManager::GetOpenStudies()
   std::vector<std::string> aVector;
   int aLength, i;
 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(TColStd_HSequenceOfTransient) aSeq = _local_impl->GetOpenStudies();
     aLength = aSeq->Length();
     for(i = 1; i <= aLength; i++) 
@@ -180,18 +185,20 @@ std::vector<std::string> SALOMEDS_StudyManager::GetOpenStudies()
   }
   return aVector;
 }
- 
+
 _PTR(Study) SALOMEDS_StudyManager::GetStudyByName(const std::string& theStudyName) 
 {
   SALOMEDSClient_Study* aStudy = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_Study) aStudy_impl = _local_impl->GetStudyByName((char*)theStudyName.c_str());
     if(aStudy_impl.IsNull()) return _PTR(Study)(aStudy);
     aStudy = new SALOMEDS_Study(aStudy_impl);
   }
   else  {
     SALOMEDS::Study_var aStudy_impl = _corba_impl->GetStudyByName((char*)theStudyName.c_str());
-    if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy); 
+    if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy);
     aStudy = new SALOMEDS_Study(aStudy_impl);
   }
   return _PTR(Study)(aStudy);
@@ -200,25 +207,29 @@ _PTR(Study) SALOMEDS_StudyManager::GetStudyByName(const std::string& theStudyNam
 _PTR(Study) SALOMEDS_StudyManager::GetStudyByID(int theStudyID) 
 {
   SALOMEDSClient_Study* aStudy = NULL;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_Study) aStudy_impl = _local_impl->GetStudyByID(theStudyID);
     if(aStudy_impl.IsNull()) return _PTR(Study)(aStudy);
     aStudy = new SALOMEDS_Study(aStudy_impl);
   }
   else { 
     SALOMEDS::Study_var aStudy_impl = _corba_impl->GetStudyByID(theStudyID);
-    if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy); 
+    if(CORBA::is_nil(aStudy_impl)) return _PTR(Study)(aStudy);
     aStudy = new SALOMEDS_Study(aStudy_impl);
   }
-  return _PTR(Study)(aStudy); 
+  return _PTR(Study)(aStudy);
 }
- 
+
 bool SALOMEDS_StudyManager::CanCopy(const _PTR(SObject)& theSO)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   bool ret;
 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = aSO->GetLocalImpl();
     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
     ret = _local_impl->CanCopy(aSO_impl, aDriver);
@@ -230,12 +241,14 @@ bool SALOMEDS_StudyManager::CanCopy(const _PTR(SObject)& theSO)
 
   return ret;
 }
- 
+
 bool SALOMEDS_StudyManager::Copy(const _PTR(SObject)& theSO)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   bool ret;
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = aSO->GetLocalImpl();
     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
     ret = _local_impl->Copy(aSO_impl, aDriver);
@@ -246,13 +259,15 @@ bool SALOMEDS_StudyManager::Copy(const _PTR(SObject)& theSO)
   }
   return ret;
 }
- 
+
 bool SALOMEDS_StudyManager::CanPaste(const _PTR(SObject)& theSO)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   bool ret;
 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = aSO->GetLocalImpl();
     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
     ret = _local_impl->CanPaste(aSO_impl, aDriver);
@@ -264,13 +279,15 @@ bool SALOMEDS_StudyManager::CanPaste(const _PTR(SObject)& theSO)
 
   return ret;
 }
- 
+
 _PTR(SObject) SALOMEDS_StudyManager::Paste(const _PTR(SObject)& theSO)
 {
   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
   SALOMEDSClient_SObject* aResult = NULL;
 
-  if(_isLocal) {
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+
     Handle(SALOMEDSImpl_SObject) aSO_impl = aSO->GetLocalImpl();
     SALOMEDS_Driver_i* aDriver = GetDriver(aSO_impl, _orb);
     Handle(SALOMEDSImpl_SObject) aNewSO = _local_impl->Paste(aSO_impl, aDriver);
@@ -290,9 +307,9 @@ _PTR(SObject) SALOMEDS_StudyManager::Paste(const _PTR(SObject)& theSO)
 
 void SALOMEDS_StudyManager::init_orb()
 {
-  ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
-  ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting()); 
-  _orb = init(0 , 0 ) ;     
+  ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
+  ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
+  _orb = init(0 , 0 );
 }
 
 SALOMEDS_Driver_i* GetDriver(const Handle(SALOMEDSImpl_SObject)& theObject, CORBA::ORB_ptr orb)
@@ -307,7 +324,7 @@ SALOMEDS_Driver_i* GetDriver(const Handle(SALOMEDSImpl_SObject)& theObject, CORB
       SALOMEDS::Driver_var Engine = SALOMEDS::Driver::_narrow(obj) ;
       driver = new SALOMEDS_Driver_i(Engine, orb);
     }
-  }  
+  }
 
   return driver;
 }

diff --git a/src/SALOMEDS/SALOMEDS_UseCaseBuilder.cxx b/src/SALOMEDS/SALOMEDS_UseCaseBuilder.cxx
index 3ac01ede89a5f501c3c7ed5930aaa98408e2de72..2c4cdc52cc7f35e78179acdad60f023de603f369 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_UseCaseBuilder.cxx
+++ b/src/SALOMEDS/SALOMEDS_UseCaseBuilder.cxx
@@ -25,10 +25,13 @@
 
 #include "SALOMEDS_UseCaseBuilder.hxx"
 
-#include "SALOMEDSImpl_SObject.hxx"
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SObject.hxx"
-#include "SALOMEDSImpl_UseCaseIterator.hxx"
 #include "SALOMEDS_UseCaseIterator.hxx"
+
+#include "SALOMEDSImpl_SObject.hxx"
+#include "SALOMEDSImpl_UseCaseIterator.hxx"
+
 #include <TCollection_AsciiString.hxx> 
 #include <string>
 
@@ -57,7 +60,10 @@ bool SALOMEDS_UseCaseBuilder::Append(const _PTR(SObject)& theObject)
 {
   bool ret;
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) ret = _local_impl->Append(obj->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->Append(obj->GetLocalImpl());
+  }
   else ret = _corba_impl->Append(obj->GetCORBAImpl());
   return ret;
 }
@@ -66,7 +72,10 @@ bool SALOMEDS_UseCaseBuilder::Remove(const _PTR(SObject)& theObject)
 {
   bool ret;
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) ret = _local_impl->Remove(obj->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->Remove(obj->GetLocalImpl());
+  }
   else ret = _corba_impl->Remove(obj->GetCORBAImpl());
   return ret;
 }
@@ -76,7 +85,10 @@ bool SALOMEDS_UseCaseBuilder::AppendTo(const _PTR(SObject)& theFather, _PTR(SObj
   bool ret;
   SALOMEDS_SObject* father = dynamic_cast<SALOMEDS_SObject*>(theFather.get());
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) ret = _local_impl->AppendTo(father->GetLocalImpl(), obj->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->AppendTo(father->GetLocalImpl(), obj->GetLocalImpl());
+  }
   else ret = _corba_impl->AppendTo(father->GetCORBAImpl(), obj->GetCORBAImpl());
   return ret;
 }
@@ -86,7 +98,10 @@ bool SALOMEDS_UseCaseBuilder::InsertBefore(const _PTR(SObject)& theFirst, _PTR(S
   bool ret;
   SALOMEDS_SObject* first = dynamic_cast<SALOMEDS_SObject*>(theFirst.get());
   SALOMEDS_SObject* next = dynamic_cast<SALOMEDS_SObject*>(theNext.get());
-  if(_isLocal) ret = _local_impl->InsertBefore(first->GetLocalImpl(), next->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->InsertBefore(first->GetLocalImpl(), next->GetLocalImpl());
+  }
   else ret = _corba_impl->InsertBefore(first->GetCORBAImpl(), next->GetCORBAImpl());
   return ret;
 }
@@ -95,7 +110,10 @@ bool SALOMEDS_UseCaseBuilder::SetCurrentObject(const _PTR(SObject)& theObject)
 {
   bool ret;
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) ret = _local_impl->SetCurrentObject(obj->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->SetCurrentObject(obj->GetLocalImpl());
+  }
   else ret = _corba_impl->SetCurrentObject(obj->GetCORBAImpl());
   return ret;
 }
@@ -103,7 +121,10 @@ bool SALOMEDS_UseCaseBuilder::SetCurrentObject(const _PTR(SObject)& theObject)
 bool SALOMEDS_UseCaseBuilder::SetRootCurrent()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->SetRootCurrent();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->SetRootCurrent();
+  }
   else ret = _corba_impl->SetRootCurrent();
   return ret;
 }
@@ -112,7 +133,10 @@ bool SALOMEDS_UseCaseBuilder::HasChildren(const _PTR(SObject)& theObject)
 {
   bool ret;
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) ret = _local_impl->HasChildren(obj->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->HasChildren(obj->GetLocalImpl());
+  }
   else ret = _corba_impl->HasChildren(obj->GetCORBAImpl());
   return ret;
 }
@@ -121,7 +145,10 @@ bool SALOMEDS_UseCaseBuilder::IsUseCase(const _PTR(SObject)& theObject)
 {
   bool ret;
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) ret = _local_impl->IsUseCase(obj->GetLocalImpl());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->IsUseCase(obj->GetLocalImpl());
+  }
   else ret = _corba_impl->IsUseCase(obj->GetCORBAImpl());
   return ret;
 }
@@ -129,7 +156,10 @@ bool SALOMEDS_UseCaseBuilder::IsUseCase(const _PTR(SObject)& theObject)
 bool SALOMEDS_UseCaseBuilder::SetName(const std::string& theName)
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->SetName((char*)theName.c_str());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->SetName((char*)theName.c_str());
+  }
   else ret = _corba_impl->SetName((char*)theName.c_str());
   return ret;
 }
@@ -137,7 +167,10 @@ bool SALOMEDS_UseCaseBuilder::SetName(const std::string& theName)
 _PTR(SObject) SALOMEDS_UseCaseBuilder::GetCurrentObject()
 {
   SALOMEDS_SObject* obj = NULL;
-  if(_isLocal) obj = new SALOMEDS_SObject(_local_impl->GetCurrentObject());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    obj = new SALOMEDS_SObject(_local_impl->GetCurrentObject());
+  }
   else obj = new SALOMEDS_SObject(_corba_impl->GetCurrentObject());
   return _PTR(SObject)(obj);
 }
@@ -145,7 +178,10 @@ _PTR(SObject) SALOMEDS_UseCaseBuilder::GetCurrentObject()
 std::string SALOMEDS_UseCaseBuilder::GetName()
 {
   std::string aName;
-  if(_isLocal) aName = _local_impl->GetName().ToCString();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aName = _local_impl->GetName().ToCString();
+  }
   else aName = _corba_impl->GetName();
   return aName;
 }
@@ -153,7 +189,10 @@ std::string SALOMEDS_UseCaseBuilder::GetName()
 _PTR(SObject) SALOMEDS_UseCaseBuilder::AddUseCase(const std::string& theName)
 {
   SALOMEDS_SObject* obj = NULL;
-  if(_isLocal) obj = new SALOMEDS_SObject(_local_impl->AddUseCase((char*)theName.c_str()));
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    obj = new SALOMEDS_SObject(_local_impl->AddUseCase((char*)theName.c_str()));
+  }
   else obj = new SALOMEDS_SObject(_corba_impl->AddUseCase((char*)theName.c_str()));
   return _PTR(SObject)(obj);
 }
@@ -162,7 +201,10 @@ _PTR(UseCaseIterator) SALOMEDS_UseCaseBuilder::GetUseCaseIterator(const _PTR(SOb
 {
   SALOMEDS_UseCaseIterator* it = NULL;
   SALOMEDS_SObject* obj = dynamic_cast<SALOMEDS_SObject*>(theObject.get());
-  if(_isLocal) it = new SALOMEDS_UseCaseIterator(_local_impl->GetUseCaseIterator(obj->GetLocalImpl()));
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    it = new SALOMEDS_UseCaseIterator(_local_impl->GetUseCaseIterator(obj->GetLocalImpl()));
+  }
   else it = new SALOMEDS_UseCaseIterator(_corba_impl->GetUseCaseIterator(obj->GetCORBAImpl()));
   return _PTR(UseCaseIterator)(it);
 }

diff --git a/src/SALOMEDS/SALOMEDS_UseCaseIterator.cxx b/src/SALOMEDS/SALOMEDS_UseCaseIterator.cxx
index 71fc2d899c8cd36055759ec9bda95e08934b3516..006658d15995095204a60fc4304e25d0257f826a 100644 (file)
--- a/src/SALOMEDS/SALOMEDS_UseCaseIterator.cxx
+++ b/src/SALOMEDS/SALOMEDS_UseCaseIterator.cxx
@@ -24,6 +24,8 @@
 
 
 #include "SALOMEDS_UseCaseIterator.hxx"
+
+#include "SALOMEDS.hxx"
 #include "SALOMEDS_SObject.hxx"
 
 using namespace std; 
@@ -49,28 +51,40 @@ SALOMEDS_UseCaseIterator::~SALOMEDS_UseCaseIterator()
 
 void SALOMEDS_UseCaseIterator::Init(bool theAllLevels)
 {
-  if(_isLocal) _local_impl->Init(theAllLevels);
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Init(theAllLevels);
+  }
   else _corba_impl->Init(theAllLevels);
 }
 
 bool SALOMEDS_UseCaseIterator::More()
 {
   bool ret;
-  if(_isLocal) ret = _local_impl->More();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    ret = _local_impl->More();
+  }
   else ret = _corba_impl->More();
   return ret;
 }
 
 void SALOMEDS_UseCaseIterator::Next()
 {
-  if(_isLocal) _local_impl->Next();
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    _local_impl->Next();
+  }
   else _corba_impl->Next();
 }
 
 _PTR(SObject) SALOMEDS_UseCaseIterator::Value()
 {
   SALOMEDS_SObject* aSO;
-  if(_isLocal) aSO = new SALOMEDS_SObject(_local_impl->Value());
+  if (_isLocal) {
+    SALOMEDS::Locker lock;
+    aSO = new SALOMEDS_SObject(_local_impl->Value());
+  }
   else aSO = new SALOMEDS_SObject(_corba_impl->Value());
   return _PTR(SObject)(aSO);
 }