X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSALOMEDS%2FSALOMEDS_AttributeTreeNode_i.cxx;h=ed580e800974da4d756c11d873d047c9ca180003;hb=8a89a50b36a47cba1839646c0623562f30af9c28;hp=6e575f1310ff8b49f490d352e8159e49c5457041;hpb=1f742af859d50d34c63f9dc02f9a705089bf060e;p=modules%2Fyacs.git diff --git a/src/SALOMEDS/SALOMEDS_AttributeTreeNode_i.cxx b/src/SALOMEDS/SALOMEDS_AttributeTreeNode_i.cxx index 6e575f131..ed580e800 100644 --- a/src/SALOMEDS/SALOMEDS_AttributeTreeNode_i.cxx +++ b/src/SALOMEDS/SALOMEDS_AttributeTreeNode_i.cxx @@ -1,239 +1,247 @@ -// SALOME SALOMEDS : data structure of SALOME and sources of Salome data server +// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + // File : SALOMEDS_AttributeTreeNode_i.cxx -// Author : Yves FRICAUD +// Author : Sergey RUIN // Module : SALOME -// $Header$ - -using namespace std; +// #include "SALOMEDS_AttributeTreeNode_i.hxx" -#include "SALOMEDS_SObject_i.hxx" #include "utilities.h" -#include -#include - -static Handle(TDataStd_TreeNode) GetNode(SALOMEDS::AttributeTreeNode_ptr value, - const Handle(TDataStd_TreeNode)& aNode) { - Handle(TDataStd_TreeNode) aResult = new TDataStd_TreeNode; - CORBA::String_var aString = CORBA::string_dup(value->Label()); - TDF_Label aLabel; - TDF_Tool::Label(aNode->Label().Data(), TCollection_AsciiString(aString), aLabel, 0); +#include "SALOMEDS.hxx" + +static SALOMEDSImpl_AttributeTreeNode* GetNode(SALOMEDS::AttributeTreeNode_ptr value, + SALOMEDSImpl_AttributeTreeNode* aNode) +{ + SALOMEDSImpl_AttributeTreeNode* aResult = NULL; + DF_Label aLabel = DF_Label::Label(aNode->Label(), value->Label()); if (aLabel.IsNull()) { MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such label") MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such label") return aResult; } - if (!aLabel.FindAttribute(aNode->ID(), aResult)) { + if (!(aResult=(SALOMEDSImpl_AttributeTreeNode*)aLabel.FindAttribute(aNode->ID()))) { MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such attribute") MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such attribute") } return aResult; } -void SALOMEDS_AttributeTreeNode_i::SetFather(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::SetFather(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->SetFather(GetNode(value, aNode)); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasFather() { - return Handle(TDataStd_TreeNode)::DownCast(_myAttr)->HasFather(); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasFather() +{ + SALOMEDS::Locker lock; + return dynamic_cast(_impl)->HasFather(); } -SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetFather() { - SALOMEDS_AttributeTreeNode_i* aFather = new SALOMEDS_AttributeTreeNode_i(Handle(TDataStd_TreeNode)::DownCast(_myAttr)->Father(), _myOrb); +SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetFather() +{ + SALOMEDS::Locker lock; + SALOMEDS_AttributeTreeNode_i* aFather; + aFather = new SALOMEDS_AttributeTreeNode_i(dynamic_cast(_impl)->GetFather(), _orb); +#ifndef WIN32 return aFather->POA_SALOMEDS::AttributeTreeNode::_this(); +#else + return aFather->AttributeTreeNode::_this(); +#endif } -void SALOMEDS_AttributeTreeNode_i::SetPrevious(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::SetPrevious(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->SetPrevious(GetNode(value, aNode)); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasPrevious() { - return Handle(TDataStd_TreeNode)::DownCast(_myAttr)->HasPrevious(); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasPrevious() +{ + SALOMEDS::Locker lock; + return dynamic_cast(_impl)->HasPrevious(); } -SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetPrevious() { - SALOMEDS_AttributeTreeNode_i* aPrevious = new SALOMEDS_AttributeTreeNode_i(Handle(TDataStd_TreeNode)::DownCast(_myAttr)->Previous(), _myOrb); +SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetPrevious() +{ + SALOMEDS::Locker lock; + SALOMEDS_AttributeTreeNode_i* aPrevious; + aPrevious=new SALOMEDS_AttributeTreeNode_i(dynamic_cast(_impl)->GetPrevious(), _orb); +#ifndef WIN32 return aPrevious->POA_SALOMEDS::AttributeTreeNode::_this(); +#else + return aPrevious->AttributeTreeNode::_this(); +#endif } -void SALOMEDS_AttributeTreeNode_i::SetNext(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::SetNext(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->SetNext(GetNode(value, aNode)); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasNext() { - return Handle(TDataStd_TreeNode)::DownCast(_myAttr)->HasNext(); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasNext() +{ + SALOMEDS::Locker lock; + return dynamic_cast(_impl)->HasNext(); } -SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetNext() { - SALOMEDS_AttributeTreeNode_i* aNext = new SALOMEDS_AttributeTreeNode_i(Handle(TDataStd_TreeNode)::DownCast(_myAttr)->Next(), _myOrb); +SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetNext() +{ + SALOMEDS::Locker lock; + SALOMEDS_AttributeTreeNode_i* aNext; + aNext = new SALOMEDS_AttributeTreeNode_i(dynamic_cast(_impl)->GetNext(), _orb); +#ifndef WIN32 return aNext->POA_SALOMEDS::AttributeTreeNode::_this(); +#else + return aNext->AttributeTreeNode::_this(); +#endif } -void SALOMEDS_AttributeTreeNode_i::SetFirst(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::SetFirst(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->SetFirst(GetNode(value, aNode)); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasFirst() { - return Handle(TDataStd_TreeNode)::DownCast(_myAttr)->HasFirst(); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasFirst() +{ + SALOMEDS::Locker lock; + return dynamic_cast(_impl)->HasFirst(); } -SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetFirst() { - SALOMEDS_AttributeTreeNode_i* aFirst = new SALOMEDS_AttributeTreeNode_i(Handle(TDataStd_TreeNode)::DownCast(_myAttr)->First(), _myOrb); +SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetFirst() +{ + SALOMEDS::Locker lock; + SALOMEDS_AttributeTreeNode_i* aFirst; + aFirst = new SALOMEDS_AttributeTreeNode_i(dynamic_cast(_impl)->GetFirst(), _orb); +#ifndef WIN32 return aFirst->POA_SALOMEDS::AttributeTreeNode::_this(); +#else + return aFirst->AttributeTreeNode::_this(); +#endif } -void SALOMEDS_AttributeTreeNode_i::SetTreeID(const char* value) { +void SALOMEDS_AttributeTreeNode_i::SetTreeID(const char* value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); - aNode->SetTreeID(Standard_GUID(aNode->ID())); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); + aNode->SetTreeID(value); } -char* SALOMEDS_AttributeTreeNode_i::GetTreeID() { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); - char aGUID[40]; - aNode->ID().ToCString(aGUID); - return CORBA::String_var(CORBA::string_dup(aGUID))._retn(); +char* SALOMEDS_AttributeTreeNode_i::GetTreeID() +{ + SALOMEDS::Locker lock; + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); + return CORBA::String_var(CORBA::string_dup(aNode->ID().c_str()))._retn(); } -void SALOMEDS_AttributeTreeNode_i::Append(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::Append(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->Append(GetNode(value, aNode)); } -void SALOMEDS_AttributeTreeNode_i::Prepend(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::Prepend(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->Prepend(GetNode(value, aNode)); } -void SALOMEDS_AttributeTreeNode_i::InsertBefore(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::InsertBefore(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->InsertBefore(GetNode(value, aNode)); } -void SALOMEDS_AttributeTreeNode_i::InsertAfter(SALOMEDS::AttributeTreeNode_ptr value) { +void SALOMEDS_AttributeTreeNode_i::InsertAfter(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->InsertAfter(GetNode(value, aNode)); } -void SALOMEDS_AttributeTreeNode_i::Remove() { +void SALOMEDS_AttributeTreeNode_i::Remove() +{ + SALOMEDS::Locker lock; CheckLocked(); - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); aNode->Remove(); } -CORBA::Long SALOMEDS_AttributeTreeNode_i::Depth() { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); +CORBA::Long SALOMEDS_AttributeTreeNode_i::Depth() +{ + SALOMEDS::Locker lock; + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); return aNode->Depth(); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsRoot() { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsRoot() +{ + SALOMEDS::Locker lock; + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); return aNode->IsRoot(); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsDescendant(SALOMEDS::AttributeTreeNode_ptr value) { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsDescendant(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); return aNode->IsDescendant(GetNode(value, aNode)); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsFather(SALOMEDS::AttributeTreeNode_ptr value) { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsFather(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); return aNode->IsFather(GetNode(value, aNode)); } -CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsChild(SALOMEDS::AttributeTreeNode_ptr value) { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); +CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsChild(SALOMEDS::AttributeTreeNode_ptr value) +{ + SALOMEDS::Locker lock; + SALOMEDSImpl_AttributeTreeNode* aNode = dynamic_cast(_impl); return aNode->IsChild(GetNode(value, aNode)); } -char* SALOMEDS_AttributeTreeNode_i::Label() { - TCollection_AsciiString aLabelName; - TDF_Tool::Entry(_myAttr->Label(),aLabelName); - return CORBA::String_var(CORBA::string_dup(aLabelName.ToCString()))._retn(); -} - -char* SALOMEDS_AttributeTreeNode_i::Store() { - char* aStr[4]; - - if (HasFather()) aStr[0] = GetFather()->Label(); else aStr[0] = "!"; - if (HasPrevious()) aStr[1] = GetPrevious()->Label(); else aStr[1] = "!"; - if (HasNext()) aStr[2] = GetNext()->Label(); else aStr[2] = "!"; - if (HasFirst()) aStr[3] = GetFirst()->Label(); else aStr[3] = "!"; - - int aLength = 4; - aLength += strlen(aStr[0]) + strlen(aStr[1]) + strlen(aStr[2]) + strlen(aStr[3]); - CORBA::String_var aResult = new char[aLength]; - sprintf(aResult, "%s %s %s %s", aStr[0], aStr[1], aStr[2], aStr[3]); - return aResult._retn(); +char* SALOMEDS_AttributeTreeNode_i::Label() +{ + SALOMEDS::Locker lock; + return CORBA::String_var(CORBA::string_dup(_impl->Label().Entry().c_str()))._retn(); } -void SALOMEDS_AttributeTreeNode_i::Restore(const char* value) { - Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr); - Handle(TDF_Data) DF = TDocStd_Document::Get(_myAttr->Label())->GetData(); - - char* aCopy = strdup(value); - char* adr = strtok(aCopy, " "); - - TDF_Label aLabel; - Handle(TDataStd_TreeNode) aDepNode; - - if (adr && adr[0] != '!') { - TDF_Tool::Label(DF, adr, aLabel, 1); - if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID()); - aNode->SetFather(aDepNode); - } - - adr = strtok(NULL, " "); - if (adr && adr[0] != '!') { - TDF_Tool::Label(DF, adr, aLabel, 1); - if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID()); - aNode->SetPrevious(aDepNode); - } - - adr = strtok(NULL, " "); - if (adr && adr[0] != '!') { - TDF_Tool::Label(DF, adr, aLabel, 1); - if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID()); - aNode->SetNext(aDepNode); - } - - adr = strtok(NULL, " "); - if (adr && adr[0] != '!') { - TDF_Tool::Label(DF, adr, aLabel, 1); - if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID()); - aNode->SetFirst(aDepNode); - } -}