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 2026-09-17 09:21:21

 // 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++)
  *
  * Zero-based (size_t) construction mode:
  *   NCollection_Array2(size_t theNbRows, size_t theNbCols) creates a zero-based array
  *   (LowerRow()==0, LowerCol()==0). In this mode At()/ChangeAt() and STL iterators are
  *   the preferred access path -- they address elements directly without any offset subtraction.
  *   Buffer-reuse variant NCollection_Array2(pointer, size_t, size_t) wraps an existing
  *   flat row-major buffer and does NOT own the memory.
  */
 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(int theRowLower,
                            int /*theRowUpper*/,
                            int theColLower,
                            int theColUpper) noexcept
   {
     // Calculate the offset for the beginning position
     return theColLower + (theRowLower * (theColUpper - theColLower + 1));
   }
 
   static int LastPosition(int theRowLower,
                           int theRowUpper,
                           int theColLower,
                           int theColUpper) noexcept
   {
     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() noexcept
       : NCollection_Array1<TheItemType>(),
         myLowerRow(1),
         mySizeRow(0),
         myLowerCol(1),
         mySizeCol(0)
   {
   }
 
   //! Constructor
   NCollection_Array2(const int theRowLower,
                      const int theRowUpper,
                      const int theColLower,
                      const int 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)
   {
   }
 
   //! 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())
   {
     theOther.myLowerRow = 1;
     theOther.mySizeRow  = 0;
     theOther.myLowerCol = 1;
     theOther.mySizeCol  = 0;
   }
 
   //! C array-based constructor
   explicit NCollection_Array2(const TheItemType& theBegin,
                               const int          theRowLower,
                               const int          theRowUpper,
                               const int          theColLower,
                               const int          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)
   {
   }
 
   //! Zero-based constructor: allocates theNbRows x theNbCols elements with lower bounds 0.
   //! Use At()/ChangeAt() or STL iterators for optimal access (no offset subtraction).
   explicit NCollection_Array2(const size_t theNbRows, const size_t theNbCols)
       : NCollection_Array1<TheItemType>(theNbRows * theNbCols),
         myLowerRow(0),
         mySizeRow(theNbRows),
         myLowerCol(0),
         mySizeCol(theNbCols)
   {
   }
 
   //! Zero-based buffer-reuse constructor: wraps an existing flat row-major C array.
   //! The array does NOT own the buffer and will NOT free it on destruction.
   //! Use At()/ChangeAt() or STL iterators for optimal access (no offset subtraction).
   explicit NCollection_Array2(pointer theBegin, const size_t theNbRows, const size_t theNbCols)
       : NCollection_Array1<TheItemType>(theBegin, theNbRows * theNbCols),
         myLowerRow(0),
         mySizeRow(theNbRows),
         myLowerCol(0),
         mySizeCol(theNbCols)
   {
   }
 
   //! Size (number of items).
   size_t Size() const noexcept { return mySizeRow * mySizeCol; }
 
   //! Length (legacy int-returning API).
   int Length() const noexcept { return NbRows() * NbColumns(); }
 
   //! Returns number of rows
   int NbRows() const noexcept { return static_cast<int>(mySizeRow); }
 
   //! Returns number of columns
   int NbColumns() const noexcept { return static_cast<int>(mySizeCol); }
 
   //! Returns length of the row, i.e. number of columns
   int RowLength() const noexcept { return NbColumns(); }
 
   //! Returns length of the column, i.e. number of rows
   int ColLength() const noexcept { return NbRows(); }
 
   //! LowerRow
   int LowerRow() const noexcept { return myLowerRow; }
 
   //! UpperRow
   int UpperRow() const noexcept { return myLowerRow + static_cast<int>(mySizeRow) - 1; }
 
   //! LowerCol
   int LowerCol() const noexcept { return myLowerCol; }
 
   //! UpperCol
   int UpperCol() const noexcept { return myLowerCol + static_cast<int>(mySizeCol) - 1; }
 
   //! Updates lower row
   void UpdateLowerRow(const int theLowerRow) noexcept { myLowerRow = theLowerRow; }
 
   //! Updates lower column
   void UpdateLowerCol(const int theLowerCol) noexcept { myLowerCol = theLowerCol; }
 
   //! Updates upper row
   void UpdateUpperRow(const int theUpperRow) noexcept
   {
     myLowerRow = myLowerRow - UpperRow() + theUpperRow;
   }
 
   //! Updates upper column
   void UpdateUpperCol(const int theUpperCol) noexcept
   {
     myLowerCol = myLowerCol - UpperCol() + theUpperCol;
   }
 
   //! Replaces this array by a copy of theOther array.
   //! Row and column bounds are copied from theOther.
   NCollection_Array2& Assign(const NCollection_Array2& theOther)
   {
     if (&theOther == this)
     {
       return *this;
     }
     NCollection_Array1<TheItemType>::Assign(theOther);
     myLowerRow = theOther.myLowerRow;
     mySizeRow  = theOther.mySizeRow;
     myLowerCol = theOther.myLowerCol;
     mySizeCol  = theOther.mySizeCol;
     return *this;
   }
 
   //! Copies values from theOther array without changing this array bounds.
   //! This array should be pre-allocated and have the same dimensions as theOther;
   //! otherwise exception Standard_DimensionMismatch is thrown.
   NCollection_Array2& CopyValues(const NCollection_Array2& theOther)
   {
     if (&theOther == this)
     {
       return *this;
     }
     Standard_DimensionMismatch_Raise_if(mySizeRow != theOther.mySizeRow
                                           || mySizeCol != theOther.mySizeCol,
                                         "NCollection_Array2::CopyValues");
     NCollection_Array1<TheItemType>::CopyValues(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) noexcept
   {
     if (&theOther == this)
     {
       return *this;
     }
     NCollection_Array1<TheItemType>::Move(theOther);
     myLowerRow          = theOther.myLowerRow;
     mySizeRow           = theOther.mySizeRow;
     myLowerCol          = theOther.myLowerCol;
     mySizeCol           = theOther.mySizeCol;
     theOther.myLowerRow = 1;
     theOther.mySizeRow  = 0;
     theOther.myLowerCol = 1;
     theOther.mySizeCol  = 0;
     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) noexcept
   {
     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) noexcept
   {
     return Move(std::forward<NCollection_Array2>(theOther));
   }
 
   //! Constant value access
   const_reference Value(const int theRow, const int 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 int theRow, const int theCol) const
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     return NCollection_Array1<TheItemType>::at(aPos);
   }
 
   //! Variable value access
   reference ChangeValue(const int theRow, const int theCol)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     return NCollection_Array1<TheItemType>::at(aPos);
   }
 
   //! operator() - alias to ChangeValue
   reference operator()(const int theRow, const int theCol) { return ChangeValue(theRow, theCol); }
 
   //! SetValue
   void SetValue(const int theRow, const int theCol, const TheItemType& theItem)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     NCollection_Array1<TheItemType>::at(aPos) = theItem;
   }
 
   //! SetValue
   void SetValue(const int theRow, const int theCol, TheItemType&& theItem)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     NCollection_Array1<TheItemType>::at(aPos) = std::forward<TheItemType>(theItem);
   }
 
   //! 0-based checked access independent of LowerRow()/LowerCol().
   //! @param[in] theRow 0-based row index in [0, NbRows()-1]
   //! @param[in] theCol 0-based column index in [0, NbColumns()-1]
   const_reference At(const size_t theRow, const size_t theCol) const
   {
     Standard_OutOfRange_Raise_if(theRow >= mySizeRow || theCol >= mySizeCol,
                                  "NCollection_Array2::At");
     return NCollection_Array1<TheItemType>::at(theRow * mySizeCol + theCol);
   }
 
   //! 0-based checked mutable access independent of LowerRow()/LowerCol().
   //! @param[in] theRow 0-based row index in [0, NbRows()-1]
   //! @param[in] theCol 0-based column index in [0, NbColumns()-1]
   reference ChangeAt(const size_t theRow, const size_t theCol)
   {
     Standard_OutOfRange_Raise_if(theRow >= mySizeRow || theCol >= mySizeCol,
                                  "NCollection_Array2::ChangeAt");
     return NCollection_Array1<TheItemType>::at(theRow * mySizeCol + theCol);
   }
 
   //! Emplace value at the specified row and column, constructing it in-place
   //! @param theRow row index at which to emplace the value
   //! @param theCol column index at which to emplace the value
   //! @param theArgs arguments forwarded to TheItemType constructor
   //! @return reference to the newly constructed item
   template <typename... Args>
   reference EmplaceValue(const int theRow, const int theCol, Args&&... theArgs)
   {
     const size_t aPos = (theRow - myLowerRow) * mySizeCol + (theCol - myLowerCol);
     Standard_OutOfRange_Raise_if(aPos >= this->mySize, "NCollection_Array2::EmplaceValue");
     this->myPointer[aPos] = value_type(std::forward<Args>(theArgs)...);
     return this->myPointer[aPos];
   }
 
   //! Resizes the array to specified bounds.
   //! When theToCopyData is false, the array is re-allocated without preserving data.
   //! When theToCopyData is true, copies elements in linear (row-major) order.
   //! No re-allocation is done if dimensions are unchanged.
   //! @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(int  theRowLower,
               int  theRowUpper,
               int  theColLower,
               int  theColUpper,
               bool theToCopyData)
   {
     if (!theToCopyData)
     {
       resizeNoData(theRowLower, theRowUpper, theColLower, theColUpper);
       return;
     }
     resizeImpl<false>(theRowLower, theRowUpper, theColLower, theColUpper);
   }
 
   //! Resizes the array preserving 2D element layout.
   //! When theToCopyData is false, the array is re-allocated without preserving data.
   //! When theToCopyData is true, copies min(oldNbRows,newNbRows) x min(oldNbCols,newNbCols)
   //! elements from the top-left corner of the old array to the top-left corner of the new,
   //! preserving relative (row, col) offsets from lower bounds. Trimming or growing as needed.
   //! No re-allocation is done if dimensions are unchanged.
   //! @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 ResizeWithTrim(int  theRowLower,
                       int  theRowUpper,
                       int  theColLower,
                       int  theColUpper,
                       bool theToCopyData)
   {
     if (!theToCopyData)
     {
       resizeNoData(theRowLower, theRowUpper, theColLower, theColUpper);
       return;
     }
     resizeImpl<true>(theRowLower, theRowUpper, theColLower, theColUpper);
   }
 
   //! Zero-based Resize: resizes to theNbRows x theNbCols, keeping lower bounds unchanged.
   //! No re-allocation is done if dimensions are unchanged.
   //! @param theNbRows new number of rows
   //! @param theNbCols new number of columns
   //! @param theToCopyData flag to copy existing data into new array
   void Resize(const size_t theNbRows, const size_t theNbCols, const bool theToCopyData)
   {
     Resize(myLowerRow,
            myLowerRow + static_cast<int>(theNbRows) - 1,
            myLowerCol,
            myLowerCol + static_cast<int>(theNbCols) - 1,
            theToCopyData);
   }
 
   //! Zero-based ResizeWithTrim: resizes preserving 2D layout, keeping lower bounds unchanged.
   //! No re-allocation is done if dimensions are unchanged.
   //! @param theNbRows new number of rows
   //! @param theNbCols new number of columns
   //! @param theToCopyData flag to copy existing data into new array
   void ResizeWithTrim(const size_t theNbRows, const size_t theNbCols, const bool theToCopyData)
   {
     ResizeWithTrim(myLowerRow,
                    myLowerRow + static_cast<int>(theNbRows) - 1,
                    myLowerCol,
                    myLowerCol + static_cast<int>(theNbCols) - 1,
                    theToCopyData);
   }
 
 protected:
   //! Resize without copying data.
   void resizeNoData(int theRowLower, int theRowUpper, int theColLower, int theColUpper)
   {
     Standard_RangeError_Raise_if(theRowUpper < theRowLower || theColUpper < theColLower,
                                  "NCollection_Array2::Resize");
     NCollection_Array1<TheItemType>::Resize(
       BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
       LastPosition(theRowLower, theRowUpper, theColLower, theColUpper),
       false);
     mySizeRow  = theRowUpper - theRowLower + 1;
     mySizeCol  = theColUpper - theColLower + 1;
     myLowerRow = theRowLower;
     myLowerCol = theColLower;
   }
 
   //! Internal resize with data copy.
   //! @tparam thePreserve2D if true, copies the common sub-matrix preserving
   //!   2D element positions (row, col); if false, copies elements in linear order.
   template <bool thePreserve2D>
   void resizeImpl(int theRowLower, int theRowUpper, int theColLower, int theColUpper)
   {
     Standard_RangeError_Raise_if(theRowUpper < theRowLower || theColUpper < theColLower,
                                  "NCollection_Array2::Resize");
     const size_t aNewNbRows = theRowUpper - theRowLower + 1;
     const size_t aNewNbCols = theColUpper - theColLower + 1;
     if (mySizeRow == aNewNbRows && mySizeCol == aNewNbCols)
     {
       myLowerRow = theRowLower;
       myLowerCol = theColLower;
       NCollection_Array1<TheItemType>::UpdateLowerBound(
         BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper));
       return;
     }
     if (mySizeRow == 0 || mySizeCol == 0)
     {
       resizeNoData(theRowLower, theRowUpper, theColLower, theColUpper);
       return;
     }
     const size_t aNbRowsToCopy = (std::min)(mySizeRow, aNewNbRows);
     const size_t aNbColsToCopy = (std::min)(mySizeCol, aNewNbCols);
     const size_t aOldStride    = thePreserve2D ? mySizeCol : aNbColsToCopy;
 
     NCollection_Array2<TheItemType> aTmpMovedCopy(std::move(*this));
     TheItemType*                    anOldPointer = &aTmpMovedCopy.ChangeFirst();
     NCollection_Array1<TheItemType>::Resize(
       BeginPosition(theRowLower, theRowUpper, theColLower, theColUpper),
       LastPosition(theRowLower, theRowUpper, theColLower, theColUpper),
       false);
     mySizeRow  = aNewNbRows;
     mySizeCol  = aNewNbCols;
     myLowerRow = theRowLower;
     myLowerCol = theColLower;
     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[aRowIter * aOldStride + aColIter]);
       }
     }
   }
 
 protected:
   // ---------- PROTECTED FIELDS -----------
   int    myLowerRow;
   size_t mySizeRow;
   int    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