EIC code displayed by LXR master/​include/​opencascade/​NCollection_Array2.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:04:17

 // Created on: 2002-04-15
 // Created by: Alexander Kartomin (akm)
 // Copyright (c) 2002-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef NCollection_Array2_HeaderFile
 #define NCollection_Array2_HeaderFile
 
 #include <Standard_DimensionMismatch.hxx>
 #include <Standard_OutOfMemory.hxx>
 #include <NCollection_Allocator.hxx>
 #include <Standard_OutOfRange.hxx>
 #include <NCollection_Array1.hxx>
 
 #include <NCollection_DefineAlloc.hxx>
 
 // *********************************************** Template for Array2 class
 /**
 * Purpose:   The class Array2 represents bi-dimensional arrays
 *            of fixed size known at run time.
 *            The ranges of indices are user defined.
 *
 *            Class allocates one 1D array storing full data (all Rows and Columns)
 *            and extra 1D array storing pointers to each Row.
 *
 * Warning:   Programs clients of such class must be independent
 *            of the range of the first element. Then, a C++ for
 *            loop must be written like this
 *
 *            for (i = A.LowerRow(); i <= A.UpperRow(); i++)
 *              for (j = A.LowerCol(); j <= A.UpperCol(); j++)
 */
 template <class TheItemType>
 class NCollection_Array2 : public NCollection_Array1<TheItemType>
 {
 public:
   //! Memory allocation
   DEFINE_STANDARD_ALLOC;
   DEFINE_NCOLLECTION_ALLOC;
 public:
   typedef NCollection_Allocator<TheItemType> allocator_type;
 public:
 
   // Define various type aliases for convenience
   using value_type = typename NCollection_Array1<TheItemType>::value_type;
   using size_type = typename NCollection_Array1<TheItemType>::size_type;
   using difference_type = typename NCollection_Array1<TheItemType>::difference_type;
   using pointer = typename NCollection_Array1<TheItemType>::pointer;
   using const_pointer = typename NCollection_Array1<TheItemType>::const_pointer;
   using reference = typename NCollection_Array1<TheItemType>::reference;
   using const_reference = typename NCollection_Array1<TheItemType>::const_reference;
 
   using iterator = typename NCollection_Array1<TheItemType>::iterator;
   using const_iterator = typename NCollection_Array1<TheItemType>::const_iterator;
 
   static int BeginPosition(Standard_Integer theRowLower,
                            Standard_Integer /*theRowUpper*/,
                            Standard_Integer theColLower,
                            Standard_Integer theColUpper)
   {
     // Calculate the offset for the beginning position
     return theColLower + (theRowLower * (theColUpper - theColLower + 1));
   }
 
   static int LastPosition(Standard_Integer theRowLower,
                           Standard_Integer theRowUpper,
                           Standard_Integer theColLower,
                           Standard_Integer theColUpper)
   {
     return ((theRowUpper - theRowLower + 1) * (theColUpper - theColLower + 1)) + theColLower + (theRowLower * (theColUpper - theColLower + 1)) - 1;
   }
 
 public:
   // ---------- PUBLIC METHODS ------------
 
   //! Empty constructor; should be used with caution.
   //! @sa methods Resize() and Move().
   NCollection_Array2() :
     NCollection_Array1<TheItemType>(),
     myLowerRow(1),
     mySizeRow(0),
     myLowerCol(1),
     mySizeCol(0)
   {}
 
   //! Constructor
   NCollection_Array2(const Standard_Integer theRowLower,
                      const Standard_Integer theRowUpper,
                      const Standard_Integer theColLower,
                      const Standard_Integer theColUpper) :
     NCollection_Array1<TheItemType>(BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                     LastPosition(theRowLower, theRowUpper, theColLower, theColUpper)),
     myLowerRow(theRowLower),
     mySizeRow(theRowUpper - theRowLower + 1),
     myLowerCol(theColLower),
     mySizeCol(theColUpper - theColLower + 1)
   {}
 
   //! Constructor
   explicit NCollection_Array2(const allocator_type& theAlloc,
                               const Standard_Integer theRowLower,
                               const Standard_Integer theRowUpper,
                               const Standard_Integer theColLower,
                               const Standard_Integer theColUpper) :
     NCollection_Array1<TheItemType>(theAlloc,
                                     BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                     LastPosition(theRowLower, theRowUpper, theColLower, theColUpper)),
     myLowerRow(theRowLower),
     mySizeRow(theRowUpper - theRowLower + 1),
     myLowerCol(theColLower),
     mySizeCol(theColUpper - theColLower + 1)
   {}
 
   //! Copy constructor 
   NCollection_Array2(const NCollection_Array2& theOther) :
     NCollection_Array1<TheItemType>(theOther),
     myLowerRow(theOther.LowerRow()),
     mySizeRow(theOther.NbRows()),
     myLowerCol(theOther.LowerCol()),
     mySizeCol(theOther.NbColumns())
   {}
 
   //! Move constructor
   NCollection_Array2(NCollection_Array2&& theOther) noexcept:
     NCollection_Array1<TheItemType>(std::forward<NCollection_Array2>(theOther)),
     myLowerRow(theOther.LowerRow()),
     mySizeRow(theOther.NbRows()),
     myLowerCol(theOther.LowerCol()),
     mySizeCol(theOther.NbColumns())
   {}
 
   //! C array-based constructor
   explicit NCollection_Array2(const TheItemType& theBegin,
                               const Standard_Integer theRowLower,
                               const Standard_Integer theRowUpper,
                               const Standard_Integer theColLower,
                               const Standard_Integer theColUpper) :
     NCollection_Array1<TheItemType>(theBegin,
                                     BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                     LastPosition(theRowLower, theRowUpper, theColLower, theColUpper)),
     myLowerRow(theRowLower),
     mySizeRow(theRowUpper - theRowLower + 1),
     myLowerCol(theColLower),
     mySizeCol(theColUpper - theColLower + 1)
   {}
 
   //! Size (number of items)
   Standard_Integer Size() const
   {
     return Length();
   }
   //! Length (number of items)
   Standard_Integer Length() const
   {
     return NbRows() * NbColumns();
   }
 
   //! Returns number of rows
   Standard_Integer NbRows() const
   {
     return static_cast<int>(mySizeRow);
   }
 
   //! Returns number of columns
   Standard_Integer NbColumns() const
   {
     return static_cast<int>(mySizeCol);
   }
 
   //! Returns length of the row, i.e. number of columns
   Standard_Integer RowLength() const
   {
     return NbColumns();
   }
 
   //! Returns length of the column, i.e. number of rows
   Standard_Integer ColLength() const
   {
     return NbRows();
   }
 
   //! LowerRow
   Standard_Integer LowerRow() const
   {
     return myLowerRow;
   }
   //! UpperRow
   Standard_Integer UpperRow() const
   {
     return myLowerRow + static_cast<int>(mySizeRow) - 1;
   }
   //! LowerCol
   Standard_Integer LowerCol() const
   {
     return myLowerCol;
   }
   //! UpperCol
   Standard_Integer UpperCol() const
   {
     return myLowerCol + static_cast<int>(mySizeCol) - 1;
   }
 
   //! Assignment
   NCollection_Array2& Assign(const NCollection_Array2& theOther)
   {
     if (&theOther == this)
     {
       return *this;
     }
     NCollection_Array1<TheItemType>::Assign(theOther);
     return *this;
   }
 
 
   //! Move assignment.
   //! This array will borrow all the data from theOther.
   //! The moved object will be left uninitialized and should not be used anymore.
   NCollection_Array2& Move(NCollection_Array2&& theOther)
   {
     if (&theOther == this)
     {
       return *this;
     }
     NCollection_Array1<TheItemType>::Move(theOther);
     myLowerRow = theOther.myLowerRow;
     mySizeRow = theOther.mySizeRow;
     myLowerCol = theOther.myLowerCol;
     mySizeCol = theOther.mySizeCol;
     return *this;
   }
 
   //! Move assignment.
   //! This array will borrow all the data from theOther.
   //! The moved object will be left uninitialized and should not be used anymore.
   NCollection_Array2& Move(NCollection_Array2& theOther)
   {
     return Move(std::move(theOther));
   }
 
   //! Assignment operator
   NCollection_Array2& operator= (const NCollection_Array2& theOther)
   {
     return Assign(theOther);
   }
 
   //! Move assignment operator; @sa Move()
   NCollection_Array2& operator= (NCollection_Array2&& theOther)
   {
     return Move(std::forward<NCollection_Array2>(theOther));
   }
 
   //! Constant value access
   const_reference Value(const Standard_Integer theRow,
                         const Standard_Integer theCol) const
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     return NCollection_Array1<TheItemType>::at(aPos);
   }
 
   //! operator() - alias to ChangeValue
   const_reference operator() (const Standard_Integer theRow,
                               const Standard_Integer theCol) const
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     return NCollection_Array1<TheItemType>::at(aPos);
   }
 
   //! Variable value access
   reference ChangeValue(const Standard_Integer theRow,
                         const Standard_Integer theCol)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     return NCollection_Array1<TheItemType>::at(aPos);
   }
 
   //! operator() - alias to ChangeValue
   reference operator() (const Standard_Integer theRow,
                         const Standard_Integer theCol)
   {
     return ChangeValue(theRow, theCol);
   }
 
   //! SetValue
   void SetValue(const Standard_Integer theRow,
                 const Standard_Integer theCol,
                 const TheItemType& theItem)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     NCollection_Array1<TheItemType>::at(aPos) = theItem;
   }
 
   //! SetValue
   void SetValue(const Standard_Integer theRow,
                 const Standard_Integer theCol,
                 TheItemType&& theItem)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     NCollection_Array1<TheItemType>::at(aPos) = std::forward<TheItemType>(theItem);
   }
 
   //! Resizes the array to specified bounds.
   //! No re-allocation will be done if length of array does not change,
   //! but existing values will not be discarded if theToCopyData set to FALSE.
   //! @param theRowLower new lower Row of array
   //! @param theRowUpper new upper Row of array
   //! @param theColLower new lower Column of array
   //! @param theColUpper new upper Column of array
   //! @param theToCopyData flag to copy existing data into new array
   void Resize(Standard_Integer theRowLower,
               Standard_Integer theRowUpper,
               Standard_Integer theColLower,
               Standard_Integer theColUpper,
               Standard_Boolean theToCopyData)
   {
     Standard_RangeError_Raise_if(theRowUpper < theRowLower ||
                                  theColUpper < theColLower, "NCollection_Array2::Resize");
     myLowerRow = theRowLower;
     myLowerCol = theColLower;
     if (!theToCopyData)
     {
       NCollection_Array1<TheItemType>::Resize(BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                               LastPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                               false);
       mySizeRow = theRowUpper - theRowLower + 1;
       mySizeCol = theColUpper - theColLower + 1;
       return;
     }
     NCollection_Array1<TheItemType> aTmpMovedCopy(std::move(*this));
     TheItemType* anOldPointer = &aTmpMovedCopy.ChangeFirst();
     NCollection_Array1<TheItemType>::Resize(BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                             LastPosition(theRowLower, theRowUpper, theColLower, theColUpper),
                                             false);
     const size_t aNewNbRows = theRowUpper - theRowLower + 1;
     const size_t aNewNbCols = theColUpper - theColLower + 1;
     const size_t aNbRowsToCopy = std::min<size_t>(mySizeRow, aNewNbRows);
     const size_t aNbColsToCopy = std::min<size_t>(mySizeCol, aNewNbCols);
     mySizeRow = aNewNbRows;
     mySizeCol = aNewNbCols;
     size_t aOldInter = 0;
     for (size_t aRowIter = 0; aRowIter < aNbRowsToCopy; ++aRowIter)
     {
       for (size_t aColIter = 0; aColIter < aNbColsToCopy; ++aColIter)
       {
         NCollection_Array1<TheItemType>::at(aRowIter * aNewNbCols + aColIter) = std::move(anOldPointer[aOldInter++]);
       }
     }
   }
 
 protected:
   // ---------- PROTECTED FIELDS -----------
   Standard_Integer myLowerRow;
   size_t mySizeRow;
   Standard_Integer myLowerCol;
   size_t mySizeCol;
 
   // ----------- FRIEND CLASSES ------------
   friend iterator;
   friend const_iterator;
 
 };
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team