50template<
typename T, 
typename TAllocator= HeapAllocator>
 
   77        FieldMembers( TAllocator& pAllocator, T* pCustom, 
size_t pAllocSize)
 
 
 
  110        return reinterpret_cast<T&
>(
members->u);
 
 
  139    : 
members(other.members)                                             { other.members= 
nullptr; }
 
 
  150        if (
this == &other || this->members == other.members)
 
  161        if((
members= other.members) != 
nullptr)
 
 
  186        other.members= 
nullptr;
 
 
  201    template<  
typename... TArgs, 
typename TRequires= TAllocator>
 
  202    requires ( !std::default_initializable<TRequires> )
 
  205        auto* mem= allocator().template Alloc<FieldMembers<T>>();
 
  206        members   = 
reinterpret_cast<FieldMembers<void*>*
>(mem);
 
  207        new (
members)  FieldMembers<void*>(allocator, &mem->u, 
sizeof(FieldMembers<T>));
 
  208        new (&mem->u) T(std::forward<TArgs>(args)...);
 
 
  225    template <
typename... TArgs, 
typename TRequires= TAllocator>
 
  226    requires(    std::is_default_constructible_v<TRequires>
 
  227              && !std::is_same_v<std::decay_t<TArgs>... , 
SharedPtr>
 
  228              && (
sizeof...(TArgs) > 0)                           )
 
  231        auto* mem= TAllocator()().
template Alloc<FieldMembers<T>>();
 
  232        members   = 
reinterpret_cast<FieldMembers<void*>*
>(mem);
 
  233        new (
members)  FieldMembers<void*>(&mem->u, 
sizeof(FieldMembers<T>));
 
  234        new (&mem->u) T(std::forward<TArgs>(args)...);
 
 
  247    template <
typename TDerived, 
typename TRequires= TAllocator, 
typename... TArgs>
 
  248    requires std::is_default_constructible_v<TRequires>
 
  254        auto* mem= TAllocator()().
template Alloc<FieldMembers<TDerived>>();
 
  255        members   = 
reinterpret_cast<FieldMembers<void*>*
>(mem);
 
  257                                            sizeof(FieldMembers<TDerived>)        );
 
  258        new (&mem->u) TDerived(std::forward<TArgs>(args)...);
 
 
  272    template <
typename TDerived, 
typename TRequires= TAllocator, 
typename... TArgs>
 
  273    requires( !std::is_default_constructible_v<TRequires> )
 
  281        auto* mem= allocator().template Alloc<FieldMembers<TDerived>>();
 
  282        members   = 
reinterpret_cast<FieldMembers<void*>*
>(mem);
 
  283        new (
members)  FieldMembers<void*>( allocator,
 
  285                                            sizeof(FieldMembers<TDerived>)        );
 
  286        new (&mem->u) TDerived(std::forward<TArgs>(args)...);
 
 
  303    template<
typename TStored= T>
 
  304    static constexpr size_t SizeOfAllocation()    noexcept { 
return sizeof(FieldMembers<TStored>); }
 
  311        return members->GetAllocator();
 
 
  351    operator          bool()                           const noexcept { 
return members != 
nullptr; }
 
 
  370template<
typename T, 
typename TAllocator= lang::HeapAllocator>
 
T StoredType
Exposes the stored type specified with template parameter T.
void InsertDerived(TAllocator &allocator, TArgs &&... args)
bool operator==(std::nullptr_t) const noexcept
AllocatorType & GetAllocator() const
static constexpr size_t SizeOfAllocation() noexcept
bool Unique() const noexcept
SharedPtr(const SharedPtr &other) noexcept
lang::AllocatorInterface< TAllocator > AI() const noexcept
TAllocator AllocatorType
Exposes the allocator as given with template parameter TAllocator.
T & getR() const noexcept
SharedPtr & operator=(SharedPtr &&other) noexcept
FieldMembers< void * > * members
SharedPtr(TAllocator &allocator, TArgs &&... args)
void InsertDerived(TArgs &&... args)
SharedPtr & operator=(const SharedPtr &other) noexcept
SharedPtr(std::nullptr_t) noexcept
SharedPtr(TArgs &&... args)
void operator=(std::nullptr_t)
Assignment of nullptr. Same as SetNulled.
bool IsNulled() const noexcept
bool operator!=(std::nullptr_t) const noexcept
SharedPtr() noexcept
Default Constructor. Leaves this object nulled.
T * getP() const noexcept
SharedPtr(SharedPtr &&other) noexcept
unsigned int UseCount() const noexcept
#define ALIB_ASSERT_ERROR(cond, domain,...)
ALIB_WARNINGS_RESTORE TTo * SafeCast(TFrom *derived)
containers::SharedPtr< T, TAllocator > SharedPtr
Type alias in namespace alib.
FieldMembers(TAllocator &pAllocator, T *pCustom, size_t pAllocSize)
size_t allocSize
The size of the allocated pair of these fields and the custom type.
std::atomic< unsigned int > refCount
The reference counter used to implement the std::shared_ptr behavior.
T * custom
The duly cast pointer to the custom type behind us.
FieldMembers(T *pCustom, size_t pAllocSize)
U u
The instance, either derived or T.
AllocatorMember()=delete
Deleted default constructor. (The allocator has to be given with construction)