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

File indexing completed on 2026-09-12 09:18:06

 // Copyright (c) 2023 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_OccAllocator_HeaderFile
 #define _NCollection_OccAllocator_HeaderFile
 
 #include <NCollection_BaseAllocator.hxx>
 #include <Standard.hxx>
 
 #include <memory>
 #include <type_traits>
 
 //! Implements allocator requirements as defined in ISO C++ Standard 2003, section 20.1.5.
 /*! The allocator uses a standard OCCT mechanism for memory
   allocation and deallocation. It can be used with standard
   containers (std::vector, std::map, etc.) to take advantage of OCCT memory optimizations.
 
   Example of use:
   \code
   NCollection_OccAllocator<TopoDS_Shape> anSAllocator();
   std::list<TopoDS_Shape, NCollection_OccAllocator<TopoDS_Shape>> aList(anSAllocator);
   TopoDS_Solid aSolid = BRepPrimAPI_MakeBox(10., 20., 30.);
   aList.push_back(aSolid);
   \endcode
 */
 template <typename ItemType>
 class NCollection_OccAllocator
 {
 public:
   typedef ItemType          value_type;
   typedef value_type*       pointer;
   typedef const value_type* const_pointer;
   typedef value_type&       reference;
   typedef const value_type& const_reference;
   typedef size_t            size_type;
   typedef ptrdiff_t         difference_type;
   typedef std::false_type   propagate_on_container_move_assignment; // std::false_type
 
   template <typename OtherType>
   struct rebind
   {
     typedef NCollection_OccAllocator<OtherType> other;
   };
 
   //! Constructor.
   //! Creates an object using the default Open CASCADE allocation mechanism, i.e., which uses
   //! Standard::Allocate() and Standard::Free() underneath.
   NCollection_OccAllocator() noexcept
       : myAllocator(nullptr)
   {
   }
 
   //! Constructor.
   NCollection_OccAllocator(const occ::handle<NCollection_BaseAllocator>& theAlloc)
       : myAllocator(theAlloc)
   {
   }
 
   //! Constructor.
   NCollection_OccAllocator(occ::handle<NCollection_BaseAllocator>&& theAlloc)
       : myAllocator(theAlloc)
   {
   }
 
   //! Constructor.
   NCollection_OccAllocator(const NCollection_OccAllocator& theOther)
 
     = default;
 
   //! Constructor.
   NCollection_OccAllocator(NCollection_OccAllocator&& theOther) noexcept
       : myAllocator(theOther.myAllocator)
   {
   }
 
   //! Assignment operator
   NCollection_OccAllocator& operator=(const NCollection_OccAllocator& theOther) = default;
 
   //! Assignment operator
   NCollection_OccAllocator& operator=(NCollection_OccAllocator&& theOther) noexcept
   {
     myAllocator = theOther.myAllocator;
     return *this;
   }
 
   //! Assignment operator
   template <typename OtherType>
   NCollection_OccAllocator& operator=(const NCollection_OccAllocator<OtherType>& theOther)
   {
     myAllocator = theOther.myAllocator;
     return *this;
   }
 
   //! Constructor.
   //! Creates an object using the default Open CASCADE allocation mechanism, i.e., which uses
   //! Standard::Allocate() and Standard::Free() underneath.
   template <typename OtherType>
   NCollection_OccAllocator(const NCollection_OccAllocator<OtherType>& theOther)
       : myAllocator(theOther.Allocator())
   {
   }
 
   void SetAllocator(const occ::handle<NCollection_BaseAllocator>& theAlloc)
   {
     myAllocator = theAlloc;
   }
 
   const occ::handle<NCollection_BaseAllocator>& Allocator() const noexcept { return myAllocator; }
 
   //! Allocates memory for theSize objects.
   pointer allocate(size_type theSize, const void* = nullptr)
   {
     return static_cast<pointer>(myAllocator.IsNull()
                                   ? Standard::AllocateOptimal(theSize * sizeof(ItemType))
                                   : myAllocator->AllocateOptimal(theSize * sizeof(ItemType)));
   }
 
   //! Template version of function Free(), nullifies the argument pointer
   //! @param thePtr - previously allocated memory block to be freed
   template <typename T>
   void deallocate(T* thePnt, size_type)
   {
     myAllocator.IsNull() ? Standard::Free(thePnt) : myAllocator->Free(thePnt);
   }
 
   //! Frees previously allocated memory.
   void deallocate(pointer thePnt, size_type)
   {
     typedef typename std::remove_const<value_type>::type non_const_value_type;
     non_const_value_type* aPnt = const_cast<non_const_value_type*>(thePnt);
     myAllocator.IsNull() ? Standard::Free(aPnt) : myAllocator->Free(aPnt);
   }
 
   //! Constructs an object.
   //! Uses placement new operator and copy constructor to construct an object.
   template <class _Objty, class... _Types>
   void construct(_Objty* _Ptr, _Types&&... _Args)
   {
     ::new ((void*)_Ptr) _Objty(std::forward<_Types>(_Args)...);
   }
 
   //! Returns an object address.
   template <typename Type = value_type>
   typename std::enable_if<!std::is_const<Type>::value, pointer>::type address(
     reference theItem) const noexcept
   {
     return &theItem;
   }
 
   //! Returns an object address.
   const_pointer address(const_reference theItem) const noexcept { return &theItem; }
 
   //! Destroys the object.
   //! Uses the object destructor.
   template <class _Uty>
   void destroy(_Uty* _Ptr) noexcept(std::is_nothrow_destructible<_Uty>::value)
   {
     (void)_Ptr;
     _Ptr->~_Uty();
   }
 
   //! Estimate maximum array size
   size_t max_size() const noexcept { return ((size_t)(-1) / sizeof(ItemType)); }
 
   bool operator==(const NCollection_OccAllocator& theOther) const noexcept
   {
     return theOther.Allocator() == myAllocator;
   }
 
   template <class U>
   bool operator==(const NCollection_OccAllocator<U>& theOther) const noexcept
   {
     return theOther.Allocator() == myAllocator;
   }
 
   bool operator!=(const NCollection_OccAllocator& theOther) const noexcept
   {
     return theOther.Allocator() != myAllocator;
   }
 
   template <class U>
   bool operator!=(const NCollection_OccAllocator<U>& theOther) const noexcept
   {
     return theOther.Allocator() != myAllocator;
   }
 
 private:
   occ::handle<NCollection_BaseAllocator> myAllocator;
 };
 
 template <class U, class V>
 bool operator==(const NCollection_OccAllocator<U>& theFirst,
                 const NCollection_OccAllocator<V>& theSecond) noexcept
 {
   return theFirst.Allocator() == theSecond.Allocator();
 }
 
 #endif

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