X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSALOMEDS%2FSALOMEDS_AttributeTableOfInteger.cxx;h=c02aaee0a6fda5af2c5b391ef21e8e44cd3bcf0a;hb=9a965a48d4bc1a6cd1f73229a91e77b10bffa881;hp=a7bbc04514d51c5bd8b2f124be5489dacb74626b;hpb=e6bfea36374791cd31c274a2f97df90dc60ddaf3;p=modules%2Fyacs.git diff --git a/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx b/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx index a7bbc0451..c02aaee0a 100644 --- a/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx +++ b/src/SALOMEDS/SALOMEDS_AttributeTableOfInteger.cxx @@ -1,37 +1,34 @@ -// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE +// +// 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. -// -// 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 +// 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 +// 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_AttributeTableOfInteger.cxx // Author : Sergey RUIN // Module : SALOME - +// #include "SALOMEDS_AttributeTableOfInteger.hxx" #include "SALOMEDS.hxx" -#include -#include -#include -#include - - SALOMEDS_AttributeTableOfInteger::SALOMEDS_AttributeTableOfInteger - (const Handle(SALOMEDSImpl_AttributeTableOfInteger)& theAttr) + (SALOMEDSImpl_AttributeTableOfInteger* theAttr) :SALOMEDS_GenericAttribute(theAttr) {} @@ -49,7 +46,7 @@ void SALOMEDS_AttributeTableOfInteger::SetTitle(const std::string& theTitle) if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetTitle((char*)theTitle.c_str()); + dynamic_cast(_local_impl)->SetTitle(theTitle); } else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetTitle(theTitle.c_str()); } @@ -59,8 +56,7 @@ std::string SALOMEDS_AttributeTableOfInteger::GetTitle() std::string aStr; if (_isLocal) { SALOMEDS::Locker lock; - aStr = TCollection_AsciiString(Handle(SALOMEDSImpl_AttributeTableOfInteger):: - DownCast(_local_impl)->GetTitle()).ToCString(); + aStr = dynamic_cast(_local_impl)->GetTitle(); } else aStr = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetTitle(); return aStr; @@ -71,21 +67,38 @@ void SALOMEDS_AttributeTableOfInteger::SetRowTitle(int theIndex, const std::stri if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger):: - DownCast(_local_impl)->SetRowTitle(theIndex, (char*)theTitle.c_str()); + dynamic_cast(_local_impl)->SetRowTitle(theIndex, theTitle); } else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRowTitle(theIndex, theTitle.c_str()); } +std::string SALOMEDS_AttributeTableOfInteger::GetRowTitle(int theIndex) +{ + std::string aTitle; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aTitle = dynamic_cast(_local_impl)->GetRowTitle(theIndex); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + aTitle = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowTitle(theIndex); + } + return aTitle; +} + void SALOMEDS_AttributeTableOfInteger::SetRowTitles(const std::vector& theTitles) { int aLength = theTitles.size(), i; 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()); - Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetRowTitles(aSeq); + std::vector aSeq; + for (i = 0; i < aLength; i++) aSeq.push_back(theTitles[i]); + dynamic_cast(_local_impl)->SetRowTitles(aSeq); } else { SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq(); @@ -102,10 +115,7 @@ std::vector SALOMEDS_AttributeTableOfInteger::GetRowTitles() int aLength, i; if (_isLocal) { SALOMEDS::Locker lock; - Handle(TColStd_HSequenceOfExtendedString) aSeq; - aSeq = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetRowTitles(); - aLength = aSeq->Length(); - for(i = 1; i<= aLength; i++) aVector.push_back(TCollection_AsciiString((aSeq->Value(i))).ToCString()); + aVector = dynamic_cast(_local_impl)->GetRowTitles(); } else { SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowTitles(); @@ -120,21 +130,38 @@ void SALOMEDS_AttributeTableOfInteger::SetColumnTitle(int theIndex, const std::s if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger):: - DownCast(_local_impl)->SetColumnTitle(theIndex, (char*)theTitle.c_str()); + dynamic_cast(_local_impl)->SetColumnTitle(theIndex, theTitle); } else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetColumnTitle(theIndex, theTitle.c_str()); } +std::string SALOMEDS_AttributeTableOfInteger::GetColumnTitle(int theIndex) +{ + std::string aTitle; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aTitle = dynamic_cast(_local_impl)->GetColumnTitle(theIndex); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + aTitle = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetColumnTitle(theIndex); + } + return aTitle; +} + void SALOMEDS_AttributeTableOfInteger::SetColumnTitles(const std::vector& theTitles) { int aLength = theTitles.size(), i; 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()); - Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetColumnTitles(aSeq); + std::vector aSeq; + for (i = 0; i < aLength; i++) aSeq.push_back(theTitles[i]); + dynamic_cast(_local_impl)->SetColumnTitles(aSeq); } else { SALOMEDS::StringSeq_var aSeq = new SALOMEDS::StringSeq(); @@ -150,10 +177,7 @@ std::vector SALOMEDS_AttributeTableOfInteger::GetColumnTitles() int aLength, i; 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()); + aVector = dynamic_cast(_local_impl)->GetColumnTitles(); } else { SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetColumnTitles(); @@ -168,26 +192,41 @@ void SALOMEDS_AttributeTableOfInteger::SetRowUnit(int theIndex, const std::strin if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger):: - DownCast(_local_impl)->SetRowUnit(theIndex, (char*)theUnit.c_str()); + dynamic_cast(_local_impl)->SetRowUnit(theIndex, theUnit); } else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRowUnit(theIndex, theUnit.c_str()); } +std::string SALOMEDS_AttributeTableOfInteger::GetRowUnit(int theIndex) +{ + std::string aTitle; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aTitle = dynamic_cast(_local_impl)->GetRowUnit(theIndex); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + aTitle = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowUnit(theIndex); + } + return aTitle; +} + void SALOMEDS_AttributeTableOfInteger::SetRowUnits(const std::vector& theUnits) { int aLength = theUnits.size(), i; 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()); - Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetRowUnits(aSeq); + dynamic_cast(_local_impl)->SetRowUnits(theUnits); } 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] = theUnits[i].c_str(); SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRowUnits(aSeq); } } @@ -198,10 +237,7 @@ std::vector SALOMEDS_AttributeTableOfInteger::GetRowUnits() int aLength, i; 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()); + aVector = dynamic_cast(_local_impl)->GetRowUnits(); } else { SALOMEDS::StringSeq_var aSeq = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowUnits(); @@ -216,7 +252,7 @@ int SALOMEDS_AttributeTableOfInteger::GetNbRows() int aNb; if (_isLocal) { SALOMEDS::Locker lock; - aNb = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetNbRows(); + aNb = dynamic_cast(_local_impl)->GetNbRows(); } else aNb = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetNbRows(); return aNb; @@ -227,7 +263,7 @@ int SALOMEDS_AttributeTableOfInteger::GetNbColumns() int aNb; if (_isLocal) { SALOMEDS::Locker lock; - aNb = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->GetNbColumns(); + aNb = dynamic_cast(_local_impl)->GetNbColumns(); } else aNb = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetNbColumns(); return aNb; @@ -240,15 +276,12 @@ void SALOMEDS_AttributeTableOfInteger::AddRow(const std::vector& theData) if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable; - aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl); - Handle(TColStd_HSequenceOfInteger) aRow = new TColStd_HSequenceOfInteger; - for (int i = 0; i < aLength; i++) aRow->Append(theData[i]); + SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast(_local_impl); try { - aTable->SetRowData(aTable->GetNbRows() + 1, aRow); + aTable->SetRowData(aTable->GetNbRows() + 1, theData); } catch(...) { - throw SALOMEDS::AttributeTableOfInteger::IncorrectArgumentLength(); + throw SALOMEDS::AttributeTable::IncorrectArgumentLength(); } } else { @@ -265,15 +298,12 @@ void SALOMEDS_AttributeTableOfInteger::SetRow(int theRow, const std::vector if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable; - aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl); - Handle(TColStd_HSequenceOfInteger) aRow = new TColStd_HSequenceOfInteger; - for (int i = 0; i < aLength; i++) aRow->Append(theData[i]); + SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast(_local_impl); try { - aTable->SetRowData(theRow, aRow); + aTable->SetRowData(theRow, theData); } catch(...) { - throw SALOMEDS::AttributeTableOfInteger::IncorrectArgumentLength(); + throw SALOMEDS::AttributeTable::IncorrectArgumentLength(); } } else { @@ -290,13 +320,11 @@ std::vector SALOMEDS_AttributeTableOfInteger::GetRow(int theRow) int aLength, i; 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)); + aVector = dynamic_cast(_local_impl)->GetRowData(theRow); } else { SALOMEDS::LongSeq_var aRow = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRow(theRow); + aLength = aRow->length(); for (i = 0; i < aLength; i++) aVector.push_back(aRow[i]); } @@ -309,15 +337,12 @@ void SALOMEDS_AttributeTableOfInteger::AddColumn(const std::vector& theData if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable; - aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl); - Handle(TColStd_HSequenceOfInteger) aColumn = new TColStd_HSequenceOfInteger; - for (int i = 0; i < aLength; i++) aColumn->Append(theData[i]); + SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast(_local_impl); try { - aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn); + aTable->SetColumnData(aTable->GetNbColumns() + 1, theData); } catch(...) { - throw SALOMEDS::AttributeTableOfInteger::IncorrectArgumentLength(); + throw SALOMEDS::AttributeTable::IncorrectArgumentLength(); } } else { @@ -334,22 +359,19 @@ void SALOMEDS_AttributeTableOfInteger::SetColumn(int theColumn, const std::vecto if (_isLocal) { CheckLocked(); SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable; - aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl); - Handle(TColStd_HSequenceOfInteger) aColumn = new TColStd_HSequenceOfInteger; - for (int i = 0; i < aLength; i++) aColumn->Append(theData[i]); + SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast(_local_impl); try { - aTable->SetRowData(theColumn, aColumn); + aTable->SetColumnData(theColumn, theData); } catch(...) { - throw SALOMEDS::AttributeTableOfInteger::IncorrectArgumentLength(); + throw SALOMEDS::AttributeTable::IncorrectArgumentLength(); } } else { SALOMEDS::LongSeq_var aColumn = new SALOMEDS::LongSeq(); aColumn->length(aLength); for (i = 0; i < aLength; i++) aColumn[i] = theData[i]; - SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetRow(theColumn, aColumn); + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetColumn(theColumn, aColumn); } } @@ -359,13 +381,11 @@ std::vector SALOMEDS_AttributeTableOfInteger::GetColumn(int theColumn) int aLength, i; 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)); + aVector = dynamic_cast(_local_impl)->GetColumnData(theColumn); } else { SALOMEDS::LongSeq_var aColumn = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetColumn(theColumn); + aLength = aColumn->length(); for (i = 0; i < aLength; i++) aVector.push_back(aColumn[i]); } return aVector; @@ -377,11 +397,10 @@ void SALOMEDS_AttributeTableOfInteger::PutValue(int theValue, int theRow, int th CheckLocked(); SALOMEDS::Locker lock; try { - Handle(SALOMEDSImpl_AttributeTableOfInteger):: - DownCast(_local_impl)->PutValue(theValue, theRow, theColumn); + dynamic_cast(_local_impl)->PutValue(theValue, theRow, theColumn); } catch(...) { - throw SALOMEDS::AttributeTableOfInteger::IncorrectIndex(); + throw SALOMEDS::AttributeTable::IncorrectIndex(); } } else { @@ -394,7 +413,7 @@ bool SALOMEDS_AttributeTableOfInteger::HasValue(int theRow, int theColumn) bool ret; if (_isLocal) { SALOMEDS::Locker lock; - ret = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->HasValue(theRow, theColumn); + ret = dynamic_cast(_local_impl)->HasValue(theRow, theColumn); } else ret = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->HasValue(theRow, theColumn); return ret; @@ -406,11 +425,10 @@ int SALOMEDS_AttributeTableOfInteger::GetValue(int theRow, int theColumn) if (_isLocal) { SALOMEDS::Locker lock; try { - aValue = Handle(SALOMEDSImpl_AttributeTableOfInteger):: - DownCast(_local_impl)->GetValue(theRow, theColumn); + aValue = dynamic_cast(_local_impl)->GetValue(theRow, theColumn); } catch(...) { - throw SALOMEDS::AttributeTableOfInteger::IncorrectIndex(); + throw SALOMEDS::AttributeTable::IncorrectIndex(); } } else { @@ -419,20 +437,34 @@ int SALOMEDS_AttributeTableOfInteger::GetValue(int theRow, int theColumn) return aValue; } +void SALOMEDS_AttributeTableOfInteger::RemoveValue(int theRow, int theColumn) +{ + if (_isLocal) { + SALOMEDS::Locker lock; + try { + dynamic_cast(_local_impl)->RemoveValue(theRow, theColumn); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->RemoveValue(theRow, theColumn); + } +} + std::vector SALOMEDS_AttributeTableOfInteger::GetRowSetIndices(int theRow) { std::vector aVector; int aLength, i; 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)); + aVector = dynamic_cast(_local_impl)->GetSetRowIndices(theRow); } else { SALOMEDS::LongSeq_var aSet = SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->GetRowSetIndices(theRow); + aLength = aSet->length(); for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]); } return aVector; @@ -442,7 +474,159 @@ void SALOMEDS_AttributeTableOfInteger::SetNbColumns(int theNbColumns) { if (_isLocal) { SALOMEDS::Locker lock; - Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(_local_impl)->SetNbColumns(theNbColumns); + dynamic_cast(_local_impl)->SetNbColumns(theNbColumns); } else SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SetNbColumns(theNbColumns); } + +std::vector SALOMEDS_AttributeTableOfInteger::SortRow(int theRow, SortOrder theOrder, SortPolicy thePolicy) +{ + std::vector aVector; + int aLength, i; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aVector = dynamic_cast(_local_impl)->SortRow(theRow, + (SALOMEDSImpl_AttributeTable::SortOrder)theOrder, + (SALOMEDSImpl_AttributeTable::SortPolicy)thePolicy); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::LongSeq_var aSet = + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SortRow(theRow, + (SALOMEDS::AttributeTable::SortOrder)theOrder, + (SALOMEDS::AttributeTable::SortPolicy)thePolicy); + aLength = aSet->length(); + for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]); + } + return aVector; +} + +std::vector SALOMEDS_AttributeTableOfInteger::SortColumn(int theColumn, SortOrder theOrder, SortPolicy thePolicy) +{ + std::vector aVector; + int aLength, i; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aVector = dynamic_cast(_local_impl)->SortColumn(theColumn, + (SALOMEDSImpl_AttributeTable::SortOrder)theOrder, + (SALOMEDSImpl_AttributeTable::SortPolicy)thePolicy); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::LongSeq_var aSet = + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SortColumn(theColumn, + (SALOMEDS::AttributeTable::SortOrder)theOrder, + (SALOMEDS::AttributeTable::SortPolicy)thePolicy); + aLength = aSet->length(); + for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]); + } + return aVector; +} + +std::vector SALOMEDS_AttributeTableOfInteger::SortByRow(int theRow, SortOrder theOrder, SortPolicy thePolicy) +{ + std::vector aVector; + int aLength, i; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aVector = dynamic_cast(_local_impl)->SortByRow(theRow, + (SALOMEDSImpl_AttributeTable::SortOrder)theOrder, + (SALOMEDSImpl_AttributeTable::SortPolicy)thePolicy); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::LongSeq_var aSet = + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SortByRow(theRow, + (SALOMEDS::AttributeTable::SortOrder)theOrder, + (SALOMEDS::AttributeTable::SortPolicy)thePolicy); + aLength = aSet->length(); + for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]); + } + return aVector; +} + +std::vector SALOMEDS_AttributeTableOfInteger::SortByColumn(int theColumn, SortOrder theOrder, SortPolicy thePolicy) +{ + std::vector aVector; + int aLength, i; + if (_isLocal) { + SALOMEDS::Locker lock; + try { + aVector = dynamic_cast(_local_impl)->SortByColumn(theColumn, + (SALOMEDSImpl_AttributeTable::SortOrder)theOrder, + (SALOMEDSImpl_AttributeTable::SortPolicy)thePolicy); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::LongSeq_var aSet = + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SortByColumn(theColumn, + (SALOMEDS::AttributeTable::SortOrder)theOrder, + (SALOMEDS::AttributeTable::SortPolicy)thePolicy); + aLength = aSet->length(); + for (i = 0; i < aLength; i++) aVector.push_back(aSet[i]); + } + return aVector; +} + +void SALOMEDS_AttributeTableOfInteger::SwapCells(int theRow1, int theColumn1, int theRow2, int theColumn2) +{ + if (_isLocal) { + SALOMEDS::Locker lock; + try { + dynamic_cast(_local_impl)->SwapCells(theRow1, theColumn1, theRow2, theColumn2); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SwapCells(theRow1, theColumn1, theRow2, theColumn2); + } +} + +void SALOMEDS_AttributeTableOfInteger::SwapRows(int theRow1, int theRow2) +{ + if (_isLocal) { + SALOMEDS::Locker lock; + try { + dynamic_cast(_local_impl)->SwapRows(theRow1, theRow2); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SwapRows(theRow1, theRow2); + } +} + +void SALOMEDS_AttributeTableOfInteger::SwapColumns(int theColumn1, int theColumn2) +{ + if (_isLocal) { + SALOMEDS::Locker lock; + try { + dynamic_cast(_local_impl)->SwapColumns(theColumn1, theColumn2); + } + catch(...) { + throw SALOMEDS::AttributeTable::IncorrectIndex(); + } + } + else { + SALOMEDS::AttributeTableOfInteger::_narrow(_corba_impl)->SwapColumns(theColumn1, theColumn2); + } +}