X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSALOMEDSImpl%2FSALOMEDSImpl_AttributeTableOfInteger.cxx;h=f591f76f28ac81bbce2cd80a767e650680391966;hb=9b4e0b2a96fd8152a7f94b87e479ad9f8d0a60aa;hp=955a6fe1a6ea6168195db3204aa3c58b471be20d;hpb=e6bfea36374791cd31c274a2f97df90dc60ddaf3;p=modules%2Fkernel.git diff --git a/src/SALOMEDSImpl/SALOMEDSImpl_AttributeTableOfInteger.cxx b/src/SALOMEDSImpl/SALOMEDSImpl_AttributeTableOfInteger.cxx index 955a6fe1a..f591f76f2 100644 --- a/src/SALOMEDSImpl/SALOMEDSImpl_AttributeTableOfInteger.cxx +++ b/src/SALOMEDSImpl/SALOMEDSImpl_AttributeTableOfInteger.cxx @@ -1,140 +1,130 @@ -// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// Copyright (C) 2007-2023 CEA, EDF, 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 : SALOMEDSImpl_AttributeTableOfInteger.cxx // Author : Michael Ponikarov // Module : SALOME +// +#include "SALOMEDSImpl_AttributeTableOfInteger.hxx" -#include -#include -#include -#include -#include - -using namespace std; - -IMPLEMENT_STANDARD_HANDLE( SALOMEDSImpl_AttributeTableOfInteger, SALOMEDSImpl_GenericAttribute ) -IMPLEMENT_STANDARD_RTTIEXT( SALOMEDSImpl_AttributeTableOfInteger, SALOMEDSImpl_GenericAttribute ) +#include +#include #define SEPARATOR '\1' +typedef std::map::const_iterator MI; -static TCollection_ExtendedString getUnit(TCollection_ExtendedString theString) +static std::string getUnit(std::string theString) { - TCollection_ExtendedString aString(theString); - int aPos = aString.Search(SEPARATOR); - if(aPos <= 0 || aPos == aString.Length() ) return TCollection_ExtendedString(); - return aString.Split(aPos); + std::string aString(theString); + size_t aPos = aString.find(SEPARATOR); + return aPos >= aString.size()-1 ? std::string() : aString.substr(aPos+1); } -static TCollection_ExtendedString getTitle(TCollection_ExtendedString theString) +static std::string getTitle(std::string theString) { - TCollection_ExtendedString aString(theString); - int aPos = aString.Search(SEPARATOR); - if(aPos < 1) return aString; - if(aPos == 1) return TCollection_ExtendedString(); - aString.Split(aPos-1); - return aString; + std::string aString(theString); + size_t aPos = aString.find(SEPARATOR); + return aPos == std::string::npos ? aString : aString.substr(0, aPos); } -const Standard_GUID& SALOMEDSImpl_AttributeTableOfInteger::GetID() +const std::string& SALOMEDSImpl_AttributeTableOfInteger::GetID() { - static Standard_GUID SALOMEDSImpl_AttributeTableOfIntegerID ("128371A0-8F52-11d6-A8A3-0001021E8C7F"); + static std::string SALOMEDSImpl_AttributeTableOfIntegerID ("128371A0-8F52-11d6-A8A3-0001021E8C7F"); return SALOMEDSImpl_AttributeTableOfIntegerID; } -Handle(SALOMEDSImpl_AttributeTableOfInteger) SALOMEDSImpl_AttributeTableOfInteger::Set(const TDF_Label& label) +SALOMEDSImpl_AttributeTableOfInteger* SALOMEDSImpl_AttributeTableOfInteger::Set(const DF_Label& label) { - Handle(SALOMEDSImpl_AttributeTableOfInteger) anAttr; - if (!label.FindAttribute(SALOMEDSImpl_AttributeTableOfInteger::GetID(),anAttr)) { - anAttr = new SALOMEDSImpl_AttributeTableOfInteger(); - label.AddAttribute(anAttr); + SALOMEDSImpl_AttributeTableOfInteger* A = NULL; + if (!(A=(SALOMEDSImpl_AttributeTableOfInteger*)label.FindAttribute(SALOMEDSImpl_AttributeTableOfInteger::GetID()))) { + A = new SALOMEDSImpl_AttributeTableOfInteger(); + label.AddAttribute(A); } - return anAttr; + return A; } SALOMEDSImpl_AttributeTableOfInteger::SALOMEDSImpl_AttributeTableOfInteger() :SALOMEDSImpl_GenericAttribute("AttributeTableOfInteger") { - myRows = new TColStd_HSequenceOfExtendedString(); - myCols = new TColStd_HSequenceOfExtendedString(); myNbRows = 0; myNbColumns = 0; } -void SALOMEDSImpl_AttributeTableOfInteger::SetNbColumns(const Standard_Integer theNbColumns) +void SALOMEDSImpl_AttributeTableOfInteger::SetNbColumns(const int theNbColumns) { CheckLocked(); Backup(); - TColStd_DataMapOfIntegerInteger aMap; + std::map aMap; aMap = myTable; - myTable.Clear(); + myTable.clear(); - TColStd_DataMapIteratorOfDataMapOfIntegerInteger anIterator(aMap); - for(; anIterator.More(); anIterator.Next()) { - int aRow = (int)(anIterator.Key()/myNbColumns) + 1; - int aCol = (int)(anIterator.Key() - myNbColumns*(aRow-1)); + for(MI p = aMap.begin(); p != aMap.end(); p++) { + int aRow = (int)(p->first/myNbColumns) + 1; + int aCol = (int)(p->first - myNbColumns*(aRow-1)); if(aCol == 0) { aCol = myNbColumns; aRow--; } if(aCol > theNbColumns) continue; int aKey = (aRow-1)*theNbColumns+aCol; - myTable.Bind(aKey, anIterator.Value()); + myTable[aKey] = p->second; } myNbColumns = theNbColumns; - while (myCols->Length() < myNbColumns) { // append empty columns titles - myCols->Append(TCollection_ExtendedString("")); + while ((int)myCols.size() < myNbColumns) { // append empty columns titles // TODO: mismatch signed/unsigned + myCols.push_back(std::string("")); } SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved - } -void SALOMEDSImpl_AttributeTableOfInteger::SetTitle(const TCollection_ExtendedString& theTitle) +void SALOMEDSImpl_AttributeTableOfInteger::SetTitle(const std::string& theTitle) { CheckLocked(); Backup(); myTitle = theTitle; - + SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -TCollection_ExtendedString SALOMEDSImpl_AttributeTableOfInteger::GetTitle() const +std::string SALOMEDSImpl_AttributeTableOfInteger::GetTitle() const { return myTitle; } -void SALOMEDSImpl_AttributeTableOfInteger::SetRowData(const Standard_Integer theRow, - const Handle(TColStd_HSequenceOfInteger)& theData) +void SALOMEDSImpl_AttributeTableOfInteger::SetRowData(const int theRow, + const std::vector& theData) { CheckLocked(); - if(theData->Length() > myNbColumns) SetNbColumns(theData->Length()); + if((int)theData.size() > myNbColumns) SetNbColumns((int)theData.size()); //!< TODO: conversion from size_t to const int, possible loss of data Backup(); - while (myRows->Length() < theRow) { // append new row titles - myRows->Append(TCollection_ExtendedString("")); + while ((int)myRows.size() < theRow) { // append new row titles // TODO: mismatch signed/unsigned + myRows.push_back(std::string("")); } - Standard_Integer i, aShift = (theRow-1)*myNbColumns, aLength = theData->Length(); + size_t i, aShift = (theRow-1)*myNbColumns, aLength = theData.size(); for(i = 1; i <= aLength; i++) { - myTable.Bind(aShift + i, theData->Value(i)); + myTable[(int)(aShift + i)] = theData[i-1]; //!< TODO: conversion from size_t to int } if(theRow > myNbRows) myNbRows = theRow; @@ -142,113 +132,110 @@ void SALOMEDSImpl_AttributeTableOfInteger::SetRowData(const Standard_Integer the SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -Handle(TColStd_HSequenceOfInteger) SALOMEDSImpl_AttributeTableOfInteger::GetRowData(const Standard_Integer theRow) +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetRowData(const int theRow) { - Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger(); - Standard_Integer i, aShift = (theRow-1)*myNbColumns; + std::vector aSeq; + int i, aShift = (theRow-1)*myNbColumns; for(i = 1; i <= myNbColumns; i++) { - if(myTable.IsBound(aShift+i)) - aSeq->Append(myTable.Find(aShift+i)); + if(myTable.find(aShift+i) != myTable.end()) + aSeq.push_back(myTable[aShift+i]); else - aSeq->Append(0); + aSeq.push_back(0); } return aSeq; } -void SALOMEDSImpl_AttributeTableOfInteger::SetRowTitle(const Standard_Integer theRow, - const TCollection_ExtendedString& theTitle) +void SALOMEDSImpl_AttributeTableOfInteger::SetRowTitle(const int theRow, + const std::string& theTitle) { CheckLocked(); Backup(); - TCollection_ExtendedString aTitle(theTitle), aUnit = GetRowUnit(theRow); - if(aUnit.Length()>0) { + std::string aTitle(theTitle), aUnit = GetRowUnit(theRow); + if(aUnit.size()>0) { aTitle += SEPARATOR; aTitle += aUnit; } - myRows->SetValue(theRow, aTitle); + myRows[theRow-1] = aTitle; SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -void SALOMEDSImpl_AttributeTableOfInteger::SetRowUnit(const Standard_Integer theRow, - const TCollection_ExtendedString& theUnit) +void SALOMEDSImpl_AttributeTableOfInteger::SetRowUnit(const int theRow, + const std::string& theUnit) { CheckLocked(); Backup(); - TCollection_ExtendedString aTitle = GetRowTitle(theRow); + std::string aTitle = GetRowTitle(theRow); aTitle += SEPARATOR; aTitle += theUnit; - myRows->SetValue(theRow, aTitle); + myRows[theRow-1] = aTitle; SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -void SALOMEDSImpl_AttributeTableOfInteger::SetRowUnits(const Handle(TColStd_HSequenceOfExtendedString)& theUnits) +void SALOMEDSImpl_AttributeTableOfInteger::SetRowUnits(const std::vector& theUnits) { - if (theUnits->Length() != GetNbRows()) Standard_Failure::Raise("Invalid number of rows"); - int aLength = theUnits->Length(), i; - for(i = 1; i <= aLength; i++) SetRowUnit(i, theUnits->Value(i)); + if ((int)theUnits.size() != GetNbRows()) throw DFexception("Invalid number of rows"); // TODO: mismatch signed/unsigned + size_t aLength = theUnits.size(), i; + for(i = 1; i <= aLength; i++) SetRowUnit((int)i, theUnits[i-1]); //!< TODO: conversion from size_t to int SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -Handle(TColStd_HSequenceOfExtendedString) SALOMEDSImpl_AttributeTableOfInteger::GetRowUnits() +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetRowUnits() { - Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString; - int aLength = myRows->Length(), i; - for(i=1; i<=aLength; i++) aSeq->Append(getUnit(myRows->Value(i))); + std::vector aSeq; + size_t aLength = myRows.size(), i; + for(i=0; i& theTitles) { - if (theTitles->Length() != GetNbRows()) Standard_Failure::Raise("Invalid number of rows"); - int aLength = theTitles->Length(), i; - for(i = 1; i <= aLength; i++) SetRowTitle(i, theTitles->Value(i)); + if ((int)theTitles.size() != GetNbRows()) throw DFexception("Invalid number of rows"); //TODO: mismatch signed/unsigned + size_t aLength = theTitles.size(), i; + for(i = 1; i <= aLength; i++) SetRowTitle((int)i, theTitles[i-1]); //!< TODO: conversion from size_t to int SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -Handle(TColStd_HSequenceOfExtendedString) SALOMEDSImpl_AttributeTableOfInteger::GetRowTitles() +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetRowTitles() { - Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString; - int aLength = myRows->Length(), i; - for(i=1; i<=aLength; i++) aSeq->Append(getTitle(myRows->Value(i))); + std::vector aSeq; + size_t aLength = myRows.size(), i; + for(i=0; iValue(theRow)); + return getTitle(myRows[theRow-1]); } - -TCollection_ExtendedString SALOMEDSImpl_AttributeTableOfInteger::GetRowUnit(const Standard_Integer theRow) const +std::string SALOMEDSImpl_AttributeTableOfInteger::GetRowUnit(const int theRow) const { - return getUnit(myRows->Value(theRow)); + return getUnit(myRows[theRow-1]); } - -void SALOMEDSImpl_AttributeTableOfInteger::SetColumnData(const Standard_Integer theColumn, - const Handle(TColStd_HSequenceOfInteger)& theData) +void SALOMEDSImpl_AttributeTableOfInteger::SetColumnData(const int theColumn, + const std::vector& theData) { CheckLocked(); if(theColumn > myNbColumns) SetNbColumns(theColumn); Backup(); - Standard_Integer i, aLength = theData->Length(); + size_t i, aLength = theData.size(); for(i = 1; i <= aLength; i++) { - myTable.Bind(myNbColumns*(i-1)+theColumn, theData->Value(i)); + myTable[myNbColumns*((int)i-1)+theColumn] = theData[i-1]; //!< TODO: conversion from size_t to int } - if(aLength > myNbRows) { - myNbRows = aLength; - while (myRows->Length() < myNbRows) { // append empty row titles - myRows->Append(TCollection_ExtendedString("")); + if((int)aLength > myNbRows) { + myNbRows = (int)aLength; //!< TODO: conversion from size_t to int + while ((int)myRows.size() < myNbRows) { // append empty row titles + myRows.push_back(std::string("")); } } @@ -256,80 +243,80 @@ void SALOMEDSImpl_AttributeTableOfInteger::SetColumnData(const Standard_Integer } -Handle(TColStd_HSequenceOfInteger) SALOMEDSImpl_AttributeTableOfInteger::GetColumnData(const Standard_Integer theColumn) +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetColumnData(const int theColumn) { - Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger; - - Standard_Integer i, anIndex; + std::vector aSeq; + int i, anIndex; for(i = 1; i <= myNbRows; i++) { anIndex = myNbColumns*(i-1) + theColumn; - if(myTable.IsBound(anIndex)) - aSeq->Append(myTable.Find(anIndex)); + if(myTable.find(anIndex) != myTable.end()) + aSeq.push_back(myTable[anIndex]); else - aSeq->Append(0); + aSeq.push_back(0); } return aSeq; } -void SALOMEDSImpl_AttributeTableOfInteger::SetColumnTitle(const Standard_Integer theColumn, - const TCollection_ExtendedString& theTitle) +void SALOMEDSImpl_AttributeTableOfInteger::SetColumnTitle(const int theColumn, + const std::string& theTitle) { - CheckLocked(); + CheckLocked(); Backup(); - while(myCols->Length() < theColumn) myCols->Append(TCollection_ExtendedString("")); - myCols->SetValue(theColumn,theTitle); + while((int)myCols.size() < theColumn) myCols.push_back(std::string("")); + myCols[theColumn-1] = theTitle; SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -TCollection_ExtendedString SALOMEDSImpl_AttributeTableOfInteger::GetColumnTitle(const Standard_Integer theColumn) const +std::string SALOMEDSImpl_AttributeTableOfInteger::GetColumnTitle(const int theColumn) const { - if(myCols.IsNull()) return ""; - if(myCols->Length() < theColumn) return ""; - return myCols->Value(theColumn); + if(myCols.empty()) return ""; + if((int)myCols.size() < theColumn) return ""; + return myCols[theColumn-1]; } -void SALOMEDSImpl_AttributeTableOfInteger::SetColumnTitles(const Handle(TColStd_HSequenceOfExtendedString)& theTitles) +void SALOMEDSImpl_AttributeTableOfInteger::SetColumnTitles(const std::vector& theTitles) { - if (theTitles->Length() != myNbColumns) Standard_Failure::Raise("Invalid number of columns"); - int aLength = theTitles->Length(), i; - for(i = 1; i <= aLength; i++) myCols->SetValue(i, theTitles->Value(i)); + if ((int)theTitles.size() != myNbColumns) throw DFexception("Invalid number of columns"); + size_t aLength = theTitles.size(), i; + for(i = 0; i < aLength; i++) myCols[i] = theTitles[i]; SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -Handle(TColStd_HSequenceOfExtendedString) SALOMEDSImpl_AttributeTableOfInteger::GetColumnTitles() +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetColumnTitles() { - Handle(TColStd_HSequenceOfExtendedString) aSeq = new TColStd_HSequenceOfExtendedString; - int aLength = myCols->Length(), i; - for(i=1; i<=aLength; i++) aSeq->Append(myCols->Value(i)); + std::vector aSeq; + size_t aLength = myCols.size(), i; + for(i=0; i myNbColumns) SetNbColumns(theColumn); - Standard_Integer anIndex = (theRow-1)*myNbColumns + theColumn; - myTable.Bind(anIndex, theValue); + int anIndex = (theRow-1)*myNbColumns + theColumn; + myTable[anIndex] = theValue; if(theRow > myNbRows) { - while (myRows->Length() < theRow) { // append empty row titles - myRows->Append(TCollection_ExtendedString("")); + while ((int)myRows.size() < theRow) { // append empty row titles + myRows.push_back(std::string("")); } myNbRows = theRow; } @@ -337,41 +324,56 @@ void SALOMEDSImpl_AttributeTableOfInteger::PutValue(const Standard_Integer theVa SetModifyFlag(); //SRN: Mark the study as being modified, so it could be saved } -Standard_Boolean SALOMEDSImpl_AttributeTableOfInteger::HasValue(const Standard_Integer theRow, - const Standard_Integer theColumn) +bool SALOMEDSImpl_AttributeTableOfInteger::HasValue(const int theRow, + const int theColumn) { - if(theRow > myNbRows || theRow < 1) return Standard_False; - if(theColumn > myNbColumns || theColumn < 1) return Standard_False; - Standard_Integer anIndex = (theRow-1)*myNbColumns + theColumn; - return myTable.IsBound(anIndex); + if(theRow > myNbRows || theRow < 1) return false; + if(theColumn > myNbColumns || theColumn < 1) return false; + int anIndex = (theRow-1)*myNbColumns + theColumn; + return (myTable.find(anIndex) != myTable.end()); } -Standard_Integer SALOMEDSImpl_AttributeTableOfInteger::GetValue(const Standard_Integer theRow, - const Standard_Integer theColumn) +int SALOMEDSImpl_AttributeTableOfInteger::GetValue(const int theRow, + const int theColumn) { - if(theRow > myNbRows || theRow < 1) Standard_Failure::Raise("Invalid cell index"); - if(theColumn > myNbColumns || theColumn < 1) Standard_Failure::Raise("Invalid cell index"); + if(theRow > myNbRows || theRow < 1) throw DFexception("Invalid cell index"); + if(theColumn > myNbColumns || theColumn < 1) throw DFexception("Invalid cell index"); - Standard_Integer anIndex = (theRow-1)*myNbColumns + theColumn; - if(myTable.IsBound(anIndex)) return myTable.Find(anIndex); + int anIndex = (theRow-1)*myNbColumns + theColumn; + if(myTable.find(anIndex) != myTable.end()) return myTable[anIndex]; - Standard_Failure::Raise("Invalid cell index"); + throw DFexception("Invalid cell index"); return 0; } -const Standard_GUID& SALOMEDSImpl_AttributeTableOfInteger::ID() const +void SALOMEDSImpl_AttributeTableOfInteger::RemoveValue(const int theRow, const int theColumn) +{ + CheckLocked(); + if(theRow > myNbRows || theRow < 1) throw DFexception("Invalid cell index"); + if(theColumn > myNbColumns || theColumn < 1) throw DFexception("Invalid cell index"); + + int anIndex = (theRow-1)*myNbColumns + theColumn; + if (myTable.find(anIndex) != myTable.end()) { + //Backup(); + myTable.erase(anIndex); + SetModifyFlag(); // table is modified + } +} + +const std::string& SALOMEDSImpl_AttributeTableOfInteger::ID() const { return GetID(); } -void SALOMEDSImpl_AttributeTableOfInteger::Restore(const Handle(TDF_Attribute)& with) +void SALOMEDSImpl_AttributeTableOfInteger::Restore(DF_Attribute* with) { - Standard_Integer anIndex; - Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(with); + int anIndex; + SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast(with); + if(!aTable) throw DFexception("Can't Restore from a null attribute"); - myTable.Clear(); - myCols->Clear(); - myRows->Clear(); + myTable.clear(); + myCols.clear(); + myRows.clear(); myTable = aTable->myTable; myNbRows = aTable->myNbRows; @@ -379,26 +381,26 @@ void SALOMEDSImpl_AttributeTableOfInteger::Restore(const Handle(TDF_Attribute)& myTitle = aTable->myTitle; for(anIndex = 1; anIndex <= aTable->GetNbRows();anIndex++) - myRows->Append(aTable->GetRowTitle(anIndex)); + myRows.push_back(aTable->GetRowTitle(anIndex)); for(anIndex = 1; anIndex <= aTable->GetNbColumns(); anIndex++) - myCols->Append(aTable->GetColumnTitle(anIndex)); + myCols.push_back(aTable->GetColumnTitle(anIndex)); } -Handle(TDF_Attribute) SALOMEDSImpl_AttributeTableOfInteger::NewEmpty() const +DF_Attribute* SALOMEDSImpl_AttributeTableOfInteger::NewEmpty() const { return new SALOMEDSImpl_AttributeTableOfInteger(); } -void SALOMEDSImpl_AttributeTableOfInteger::Paste(const Handle(TDF_Attribute)& into, - const Handle(TDF_RelocationTable)&) const +void SALOMEDSImpl_AttributeTableOfInteger::Paste(DF_Attribute* into) { - Standard_Integer anIndex; - Handle(SALOMEDSImpl_AttributeTableOfInteger) aTable = Handle(SALOMEDSImpl_AttributeTableOfInteger)::DownCast(into); + int anIndex; + SALOMEDSImpl_AttributeTableOfInteger* aTable = dynamic_cast(into); + if(!aTable) throw DFexception("Can't Paste into a null attribute"); - aTable->myTable.Clear(); - aTable->myCols->Clear(); - aTable->myRows->Clear(); + aTable->myTable.clear(); + aTable->myCols.clear(); + aTable->myRows.clear(); aTable->myTable = myTable; aTable->myTitle = myTitle; @@ -406,156 +408,367 @@ void SALOMEDSImpl_AttributeTableOfInteger::Paste(const Handle(TDF_Attribute)& in aTable->myNbColumns = myNbColumns; for(anIndex = 1; anIndex <= GetNbRows();anIndex++) - aTable->myRows->Append(GetRowTitle(anIndex)); + aTable->myRows.push_back(GetRowTitle(anIndex)); for(anIndex = 1; anIndex <= GetNbColumns(); anIndex++) - aTable->myCols->Append(GetColumnTitle(anIndex)); + aTable->myCols.push_back(GetColumnTitle(anIndex)); } - -Handle_TColStd_HSequenceOfInteger SALOMEDSImpl_AttributeTableOfInteger::GetSetRowIndices(const Standard_Integer theRow) +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetSetRowIndices(const int theRow) { - Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger; + std::vector aSeq; - Standard_Integer i, aShift = myNbColumns*(theRow-1); + int i, aShift = myNbColumns*(theRow-1); for(i = 1; i <= myNbColumns; i++) { - if(myTable.IsBound(aShift + i)) aSeq->Append(i); + if(myTable.find(aShift + i) != myTable.end()) aSeq.push_back(i); } return aSeq; } -Handle_TColStd_HSequenceOfInteger SALOMEDSImpl_AttributeTableOfInteger::GetSetColumnIndices(const Standard_Integer theColumn) +std::vector SALOMEDSImpl_AttributeTableOfInteger::GetSetColumnIndices(const int theColumn) { - Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger; + std::vector aSeq; - Standard_Integer i, anIndex; + int i, anIndex; for(i = 1; i <= myNbRows; i++) { anIndex = myNbColumns*(i-1)+theColumn; - if(myTable.IsBound(anIndex)) aSeq->Append(i); + if(myTable.find(anIndex) != myTable.end()) aSeq.push_back(i); } return aSeq; } - -void SALOMEDSImpl_AttributeTableOfInteger::ConvertToString(ostrstream& theStream) +std::string SALOMEDSImpl_AttributeTableOfInteger::Save() { + std::string aString; + char* buffer = new char[1024]; int i, j, l; - theStream.precision(64); - //Title - l = myTitle.Length(); - theStream << l << "\n"; - for(i=1; i<=l; i++) - theStream << myTitle.Value(i) << "\n"; - - //Nb rows - theStream << myNbRows << "\n"; - - //Rows titles - for(i=1; i<=myNbRows; i++) { - l = myRows->Value(i).Length(); - theStream << l << "\n"; - for(j=1; j<=l; j++) - theStream << myRows->Value(i).Value(j) << "\n"; + l = (int)myTitle.size(); + sprintf(buffer, "%d\n", l); + aString+=buffer; + for(i=0; iValue(i).Length(); - theStream << l << "\n"; - for(j=1; j<=l; j++) - theStream << myCols->Value(i).Value(j) << "\n"; + for(i=0; ifirst, p->second); + aString += buffer; } - return; + delete []buffer; + return aString; } -bool SALOMEDSImpl_AttributeTableOfInteger::RestoreFromString(istrstream& theStream) +void SALOMEDSImpl_AttributeTableOfInteger::Load(const std::string& value) { - Backup(); + std::vector v; + int i, j, l, pos, aSize = (int)value.size(); + for(i = 0, pos = 0; i> l; + l = strtol(v[pos++].c_str(), NULL, 10); - myTitle = TCollection_ExtendedString(l, 0); - for(i=1; i<=l; i++) { - theStream >> anExtChar; - myTitle.SetValue(i, anExtChar); + myTitle = std::string(l, 0); + for(i=0; i> myNbRows; + myNbRows = strtol(v[pos++].c_str(), NULL, 10); //Rows titles - myRows->Clear(); + myRows.clear(); for(i=1; i<=myNbRows; i++) { - theStream >> l; - aStr = TCollection_ExtendedString(l,0); - for(j=1; j<=l; j++) { - theStream >> anExtChar; - aStr.SetValue(j, anExtChar); + l = strtol(v[pos++].c_str(), NULL, 10); + aStr = std::string(l,0); + for(j=0; jAppend(aStr); + myRows.push_back(aStr); } //Nb columns - theStream >> myNbColumns; + myNbColumns = strtol(v[pos++].c_str(), NULL, 10); //Columns titles - myCols->Clear(); + myCols.clear(); for(i=1; i<=myNbColumns; i++) { - theStream >> l; - aStr = TCollection_ExtendedString(l,0); - for(j=1; j<=l; j++) { - theStream >> anExtChar; - aStr.SetValue(j, anExtChar); + l = strtol(v[pos++].c_str(), NULL, 10); + aStr = std::string(l,0); + for(j=0; jAppend(aStr); + myCols.push_back(aStr); } //Restore the table values - theStream >> l; - myTable.Clear(); + l = strtol(v[pos++].c_str(), NULL, 10); + myTable.clear(); for(i=1; i<=l; i++) { - int aKey, aValue; - theStream >> aKey; - theStream >> aValue; - myTable.Bind(aKey, aValue); + int aKey = strtol(v[pos++].c_str(), NULL, 10); + int aValue = strtol(v[pos++].c_str(), NULL, 10); + myTable[aKey] = aValue; } +} - return true; +std::vector SALOMEDSImpl_AttributeTableOfInteger::SortRow(const int theRow, SortOrder sortOrder, SortPolicy sortPolicy ) +{ + CheckLocked(); + std::vector result; + if ( theRow > 0 && theRow <= myNbRows ) { + std::vector indices( myNbColumns ); + int cnt = 0; + for ( int i = 0; i < myNbColumns; i++ ) { + if ( sortPolicy != EmptyIgnore || HasValue(theRow, i+1) ) { + indices[cnt++] = i+1; + } + } + indices.resize(cnt); + + TableSorter sorter( this, sortOrder, sortPolicy, theRow, true ); + std::stable_sort( indices.begin(), indices.end(), sorter ); + + if ( sortPolicy == EmptyIgnore ) { + std::vector other( myNbColumns ); + cnt = 0; + for( int i = 0; i < myNbColumns; i++ ) + other[i] = HasValue(theRow, i+1) ? indices[cnt++] : i+1; + indices = other; + } + result = indices; + + for ( int col = 0; col < (int)indices.size(); col++ ) {//TODO: mismatch signed/unsigned + int idx = indices[col]; + if ( col+1 == idx ) continue; + SwapCells(theRow, col+1, theRow, idx); + int idx1 = 0; + for ( int i = col+1; i < (int)indices.size() && idx1 == 0; i++)//TODO: mismatch signed/unsigned + if ( indices[i] == col+1 ) idx1 = i; + indices[idx1] = idx; + } + // no need for SetModifyFlag(), since it is done by SwapCells() + } + return result; } +std::vector SALOMEDSImpl_AttributeTableOfInteger::SortColumn(const int theColumn, SortOrder sortOrder, SortPolicy sortPolicy ) +{ + CheckLocked(); + std::vector result; + if ( theColumn > 0 && theColumn <= myNbColumns ) { + std::vector indices( myNbRows ); + int cnt = 0; + for ( int i = 0; i < myNbRows; i++ ) { + if ( sortPolicy != EmptyIgnore || HasValue(i+1, theColumn) ) { + indices[cnt++] = i+1; + } + } + indices.resize(cnt); + + TableSorter sorter( this, sortOrder, sortPolicy, theColumn, false ); + std::stable_sort( indices.begin(), indices.end(), sorter ); + + if ( sortPolicy == EmptyIgnore ) { + std::vector other( myNbRows ); + cnt = 0; + for( int i = 0; i < myNbRows; i++ ) + other[i] = HasValue(i+1, theColumn) ? indices[cnt++] : i+1; + indices = other; + } + result = indices; + + for ( int row = 0; row < (int)indices.size(); row++ ) {//TODO: mismatch signed/unsigned + int idx = indices[row]; + if ( row+1 == idx ) continue; + SwapCells(row+1, theColumn, idx, theColumn); + int idx1 = 0; + for ( int i = row+1; i < (int)indices.size() && idx1 == 0; i++)//TODO: mismatch signed/unsigned + if ( indices[i] == row+1 ) idx1 = i; + indices[idx1] = idx; + } + // no need for SetModifyFlag(), since it is done by SwapCells() + } + return result; +} -TCollection_AsciiString SALOMEDSImpl_AttributeTableOfInteger::Save() +std::vector SALOMEDSImpl_AttributeTableOfInteger::SortByRow(const int theRow, SortOrder sortOrder, SortPolicy sortPolicy ) { - ostrstream ostr; - ConvertToString(ostr); - TCollection_AsciiString aString((char*)ostr.rdbuf()->str()); - return aString; + CheckLocked(); + std::vector result; + if ( theRow > 0 && theRow <= myNbRows ) { + std::vector indices( myNbColumns ); + int cnt = 0; + for ( int i = 0; i < myNbColumns; i++ ) { + if ( sortPolicy != EmptyIgnore || HasValue(theRow, i+1) ) { + indices[cnt++] = i+1; + } + } + indices.resize(cnt); + + TableSorter sorter( this, sortOrder, sortPolicy, theRow, true ); + std::stable_sort( indices.begin(), indices.end(), sorter ); + + if ( sortPolicy == EmptyIgnore ) { + std::vector other( myNbColumns ); + cnt = 0; + for( int i = 0; i < myNbColumns; i++ ) + other[i] = HasValue(theRow, i+1) ? indices[cnt++] : i+1; + indices = other; + } + result = indices; + + for ( int col = 0; col < (int)indices.size(); col++ ) {//TODO: mismatch signed/unsigned + int idx = indices[col]; + if ( col+1 == idx ) continue; + SwapColumns(col+1, idx); + int idx1 = 0; + for ( int i = col+1; i < (int)indices.size() && idx1 == 0; i++)//TODO: mismatch signed/unsigned + if ( indices[i] == col+1 ) idx1 = i; + indices[idx1] = idx; + } + // no need for SetModifyFlag(), since it is done by SwapColumns() + } + return result; } -void SALOMEDSImpl_AttributeTableOfInteger::Load(const TCollection_AsciiString& value) +std::vector SALOMEDSImpl_AttributeTableOfInteger::SortByColumn(const int theColumn, SortOrder sortOrder, SortPolicy sortPolicy ) { - istrstream aStream(value.ToCString(), strlen(value.ToCString())); - RestoreFromString(aStream); + CheckLocked(); + std::vector result; + if ( theColumn > 0 && theColumn <= myNbColumns ) { + std::vector indices( myNbRows ); + int cnt = 0; + for ( int i = 0; i < myNbRows; i++ ) { + if ( sortPolicy != EmptyIgnore || HasValue(i+1, theColumn) ) { + indices[cnt++] = i+1; + } + } + indices.resize(cnt); + + TableSorter sorter( this, sortOrder, sortPolicy, theColumn, false ); + std::stable_sort( indices.begin(), indices.end(), sorter ); + + if ( sortPolicy == EmptyIgnore ) { + std::vector other( myNbRows ); + cnt = 0; + for( int i = 0; i < myNbRows; i++ ) + other[i] = HasValue(i+1, theColumn) ? indices[cnt++] : i+1; + indices = other; + } + result = indices; + + for ( int row = 0; row < (int)indices.size(); row++ ) { //TODO: mismatch signed/unsigned + int idx = indices[row]; + if ( row+1 == idx ) continue; + SwapRows(row+1, idx); + int idx1 = 0; + for ( int i = row+1; i < (int)indices.size() && idx1 == 0; i++) //TODO: mismatch signed/unsigned + if ( indices[i] == row+1 ) idx1 = i; + indices[idx1] = idx; + } + // no need for SetModifyFlag(), since it is done by SwapRows() + } + return result; } + +void SALOMEDSImpl_AttributeTableOfInteger::SwapCells(const int theRow1, const int theColumn1, + const int theRow2, const int theColumn2) +{ + CheckLocked(); + if (theRow1 > myNbRows || theRow1 < 1) throw DFexception("Invalid cell index"); + if (theRow2 > myNbRows || theRow2 < 1) throw DFexception("Invalid cell index"); + if (theColumn1 > myNbColumns || theColumn1 < 1) throw DFexception("Invalid cell index"); + if (theColumn2 > myNbColumns || theColumn2 < 1) throw DFexception("Invalid cell index"); + + int anIndex1 = (theRow1-1)*myNbColumns + theColumn1; + int anIndex2 = (theRow2-1)*myNbColumns + theColumn2; + + bool hasValue1 = myTable.find(anIndex1) != myTable.end(); + bool hasValue2 = myTable.find(anIndex2) != myTable.end(); + + if (!hasValue1 && !hasValue2) return; // nothing changed + + int value1 = hasValue1 ? myTable[anIndex1] : 0; + int value2 = hasValue2 ? myTable[anIndex2] : 0; + + if (hasValue1 && hasValue2 && value1 == value2) return; // nothing changed + + if (hasValue1) myTable[anIndex2] = value1; + else myTable.erase(anIndex2); + if (hasValue2) myTable[anIndex1] = value2; + else myTable.erase(anIndex1); + + SetModifyFlag(); // table is modified +} + +void SALOMEDSImpl_AttributeTableOfInteger::SwapRows(const int theRow1, const int theRow2) +{ + CheckLocked(); + for (int i = 1; i <= myNbColumns; i++) + SwapCells(theRow1, i, theRow2, i); + // swap row titles + std::string tmp = myRows[theRow1-1]; + myRows[theRow1-1] = myRows[theRow2-1]; + myRows[theRow2-1] = tmp; + // no need for SetModifyFlag(), since it is done by SwapCells() +} + +void SALOMEDSImpl_AttributeTableOfInteger::SwapColumns(const int theColumn1, const int theColumn2) +{ + CheckLocked(); + for (int i = 1; i <= myNbRows; i++) + SwapCells(i, theColumn1, i, theColumn2); + // swap column titles + std::string tmp = myCols[theColumn1-1]; + myCols[theColumn1-1] = myCols[theColumn2-1]; + myCols[theColumn2-1] = tmp; + // no need for SetModifyFlag(), since it is done by SwapCells() +} +