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

Warning, file /include/opencascade/NCollection_SparseArrayBase.hxx was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 // Created on: 2007-01-23
 // Created by: Andrey BETENEV
 // Copyright (c) 2007-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_SparseArrayBase_HeaderFile
 #define NCollection_SparseArrayBase_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_TypeDef.hxx>
 #include <Standard_OutOfRange.hxx>
 
 /**
  * Base class for NCollection_SparseArray;
  * provides non-template implementation of general mechanics
  * of block allocation, items creation / deletion etc.
  *
  * Type-specific item operations (construction, destruction, copy)
  * are provided by the derived template class via function pointers
  * passed as arguments to the protected methods.
  */
 
 class NCollection_SparseArrayBase
 {
 public:
   //!@name Function pointer types for type-specific item operations
   //!@{
 
   //! Copy-construct a new item at theAddress from theOther
   using CreateItemFunc = void (*)(void* theAddress, void* theOther);
   //! Destroy the item at theAddress
   using DestroyItemFunc = void (*)(void* theAddress);
   //! Copy-assign the item at theAddress from theOther
   using CopyItemFunc = void (*)(void* theAddress, void* theOther);
 
   //!@}
 
 public:
   //!@name Type-independent public interface
   //!@{
 
   //! Returns number of currently contained items
   size_t Size() const noexcept { return mySize; }
 
   //! Check whether the value at given index is set
   Standard_EXPORT bool HasValue(const size_t theIndex) const;
 
   //!@}
 
 private:
   /**
    * The block of data contains array of items, counter
    * and bit field, allocated as single piece of memory addressed
    * from the blocks array (myData).
    *
    * The Block structure provides a logical view on the block,
    * and provides methods to work with bit map.
    *
    * Note that NCollection_SparseArrayBase class takes responsibility
    * for correct allocation/deallocation of all the data.
    */
 
   class Block
   {
   public:
     typedef unsigned char Cell; //!< type of items used to hold bits
 
     //! Number of bits in each cell
     static constexpr size_t BitsPerCell() noexcept { return sizeof(Cell) * 8; }
 
   public:
     //! Initializes the block by pointer to block data
     Block(void* const theAddr, const size_t theNbItems, const size_t theItemSize)
         : Count((size_t*)theAddr),
           Array((char*)theAddr + sizeof(size_t)),
           Bits((Cell*)((char*)theAddr + sizeof(size_t) + theNbItems * theItemSize))
     {
     }
 
     //! Compute required size for block data, in bytes
     static constexpr size_t Size(const size_t theNbItems, const size_t theItemSize) noexcept
     {
       return sizeof(size_t) + sizeof(Cell) * ((theNbItems + BitsPerCell() - 1) / BitsPerCell())
              + theNbItems * theItemSize;
     }
 
     //! Returns address of array from address of block
     static char* ToArray(void* const theAddress,
                          const size_t /*theNbItems*/,
                          const size_t /*theItemSize*/) noexcept
     {
       return (char*)theAddress + sizeof(size_t);
     }
 
   public:
     //! Set bit for i-th item; returns non-null if that bit has
     //! not been set previously
     Cell Set(size_t i) noexcept
     {
       Cell* abyte = Bits + i / BitsPerCell();
       Cell  amask = (Cell)('\1' << (i % BitsPerCell()));
       Cell  anold = (Cell)(*abyte & amask);
       *abyte      = (Cell)(*abyte | amask);
       return !anold;
     }
 
     //! Check bit for i-th item; returns non-null if that bit is set
     Cell IsSet(size_t i) noexcept
     {
       Cell* abyte = Bits + i / BitsPerCell();
       Cell  amask = (Cell)('\1' << (i % BitsPerCell()));
       return (Cell)(*abyte & amask);
     }
 
     //! Unset bit for i-th item; returns non-null if that bit
     //! has been set previously
     Cell Unset(size_t i) noexcept
     {
       Cell* abyte = Bits + i / BitsPerCell();
       Cell  amask = (Cell)('\1' << (i % BitsPerCell()));
       Cell  anold = (Cell)(*abyte & amask);
       *abyte      = (Cell)(*abyte & ~amask);
       return anold;
     }
 
   public:
     size_t* Count; //!< items counter
     void*   Array; //!< pointer to the data items array
     Cell*   Bits;  //!< bit map for defined/undefined flags
   };
 
 public:
   /**
    * Iterator
    */
 
   class Iterator
   {
   public:
     // Public interface
 
     //! Restart iterations on the same array
     void Restart() { init(myArr); }
 
     //! Returns True if current item is available
     bool More() const noexcept { return myHasMore; }
 
     //! Advances to the next item
     Standard_EXPORT void Next();
 
     //! Returns current index
     size_t Index() const noexcept { return myIBlock * myArr->myBlockSize + myInd; }
 
   protected:
     // Methods for descendant
 
     //! Empty constructor
     Standard_EXPORT Iterator(const NCollection_SparseArrayBase* theArray = nullptr);
 
     //! Initialize by the specified array
     Standard_EXPORT void init(const NCollection_SparseArrayBase* theArray);
 
     //! Returns address of the current item
     void* value() const noexcept { return myArr->getItem(myBlock, myInd); }
 
   private:
     const NCollection_SparseArrayBase* myArr;
     bool                               myHasMore;
     size_t                             myIBlock;
     size_t                             myInd;
     Block                              myBlock;
   };
   friend class Iterator;
 
 private:
   // Copy constructor and assignment operator are deleted
   NCollection_SparseArrayBase(const NCollection_SparseArrayBase&)            = delete;
   NCollection_SparseArrayBase& operator=(const NCollection_SparseArrayBase&) = delete;
 
 protected:
   // Object life
 
   //! Constructor; initialized by size of item, block size, and item destructor function.
   //! @param theDestroyItem is stored to enable proper item destruction in the base destructor
   NCollection_SparseArrayBase(size_t          theItemSize,
                               size_t          theBlockSize,
                               DestroyItemFunc theDestroyItem) noexcept
       : myItemSize(theItemSize),
         myBlockSize(theBlockSize),
         myNbBlocks(0),
         mySize(0),
         myData(nullptr),
         myDestroyItem(theDestroyItem)
   {
   }
 
   //! Destructor; properly destroys all items and frees all memory.
   //! Uses the stored DestroyItemFunc, so no virtual dispatch is needed.
   ~NCollection_SparseArrayBase() { clearItems(myDestroyItem); }
 
 protected:
   // Data access interface for descendants
 
   //! Creates Block structure for block pointed by theAddr
   Block getBlock(void* const theAddr) const noexcept
   {
     return Block(theAddr, myBlockSize, myItemSize);
   }
 
   //! Find address of the item in the block by index (in the block)
   void* getItem(const Block& theBlock, size_t theInd) const noexcept
   {
     return ((char*)theBlock.Array) + myItemSize * theInd;
   }
 
   //! Direct const access to the item
   void* getValue(const size_t theIndex) const
   {
     Standard_OutOfRange_Raise_if(
       !HasValue(theIndex),
       "NCollection_SparseArray::Value()") return Block::ToArray(myData[theIndex / myBlockSize],
                                                                 myBlockSize,
                                                                 myItemSize)
       + myItemSize * (theIndex % myBlockSize);
   }
 
   //! Clears all items and frees all memory.
   //! @param theDestroyItem function to call destructor on each item
   Standard_EXPORT void clearItems(DestroyItemFunc theDestroyItem);
 
   //! Deletes the item at theIndex from the array;
   //! returns True if the item was defined.
   //! @param theDestroyItem function to call destructor on the item
   Standard_EXPORT bool unsetValue(const size_t theIndex, DestroyItemFunc theDestroyItem);
 
   //! Set a value to the specified item; returns address of the set item.
   //! @param theCreateItem function to copy-construct a new item
   //! @param theCopyItem function to copy-assign an existing item
   Standard_EXPORT void* setValue(const size_t   theIndex,
                                  void* const    theValue,
                                  CreateItemFunc theCreateItem,
                                  CopyItemFunc   theCopyItem);
 
   //! Copy contents of theOther to this;
   //! assumes that this and theOther have exactly the same type of arguments.
   //! @param theCreateItem function to copy-construct a new item
   //! @param theDestroyItem function to call destructor on an item
   //! @param theCopyItem function to copy-assign an existing item
   Standard_EXPORT void assign(const NCollection_SparseArrayBase& theOther,
                               CreateItemFunc                     theCreateItem,
                               DestroyItemFunc                    theDestroyItem,
                               CopyItemFunc                       theCopyItem);
 
   //! Exchange contents of theOther and this;
   //! assumes that this and theOther have exactly the same type of arguments
   Standard_EXPORT void exchange(NCollection_SparseArrayBase& theOther) noexcept;
 
 private:
   // Implementation of memory allocation/deallocation and access mechanics
 
   //! Allocate space for at least iBlock+1 blocks
   void allocData(const size_t iBlock);
 
   //! Free specified block, destroying all items via theDestroyItem
   void freeBlock(const size_t iBlock, DestroyItemFunc theDestroyItem);
 
 protected:
   size_t          myItemSize;    //!< size of item
   size_t          myBlockSize;   //!< block size (in items)
   size_t          myNbBlocks;    //!< allocated size of blocks table
   size_t          mySize;        //!< number of currently defined items
   void**          myData;        //!< array of pointers to data blocks
   DestroyItemFunc myDestroyItem; //!< function to call destructor on items
 };
 
 #endif

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