CeresEngine 0.2.0
A game development framework
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > Class Template Reference

A special pointer that stores the pointer as an offset of the pointee to the OffsetPtr instance itself. More...

#include <CeresEngine/Foundation/OffsetPtr.hpp>

Classes

struct  const_cast_tag
 
struct  dynamic_cast_tag
 
struct  reinterpret_cast_tag
 
struct  static_cast_tag
 

Public Types

using element_type = PointedType
 
using pointer = PointedType *
 
using reference = typename std::add_lvalue_reference_t< PointedType >
 
using value_type = std::remove_cv_t< PointedType >
 
using difference_type = DifferenceType
 
using iterator_category = std::random_access_iterator_tag
 
using offset_type = OffsetType
 
template<class U >
using rebind = OffsetPtr< U, DifferenceType, OffsetType, OffsetAlignment >
 

Public Member Functions

 OffsetPtr () noexcept=default
 
 OffsetPtr (const pointer ptr) noexcept
 Creates a new OffsetPtr from a raw pointer.
 
template<typename T >
requires std::is_convertible_v<T*, PointedType*>
 OffsetPtr (T ptr) noexcept
 Creates a new OffsetPtr from a raw pointer.
 
 OffsetPtr (const OffsetPtr &ptr) noexcept
 Creates a new OffsetPtr by copying another.
 
template<typename T2 >
requires std::is_convertible_v<T2*, PointedType*>
 OffsetPtr (const OffsetPtr< T2, DifferenceType, OffsetType, OffsetAlignment > &ptr) noexcept
 Creates a new OffsetPtr by copying another.
 
OffsetPtr & operator= (const pointer from) noexcept
 Assigns the OffsetPtr from a raw pointer.
 
OffsetPtr & operator= (const OffsetPtr &ptr) noexcept
 Assigns the OffsetPtr by copying another.
 
template<class T2 >
requires std::is_convertible_v<T2*, PointedType*>
OffsetPtr & operator= (const OffsetPtr< T2, DifferenceType, OffsetType, OffsetAlignment > &ptr) noexcept
 Assigns the OffsetPtr by copying another.
 
 ~OffsetPtr ()=default
 Default destructor.
 
pointer get () const noexcept
 Obtains raw pointer from offset.
 
offset_type getOffset () const noexcept
 Obtains the internal offset of the pointer.
 
pointer operator-> () const noexcept
 Implements the pointer-like -> operator. It can return 0 pointer.
 
reference operator* () const noexcept
 Implements the dereferencing operator, if it is nullptr, behavior is undefined.
 
reference operator[] (difference_type idx) const noexcept
 Implements the indexing operator.
 
void reset () noexcept
 Resets the pointer and sets it to nullptr.
 
OffsetPtr & operator+= (difference_type offset) noexcept
 Increments the pointer by the given offset.
 
OffsetPtr & operator-= (difference_type offset) noexcept
 Decrements the pointer by the given offset.
 
OffsetPtr & operator++ (void) noexcept
 Prefix increment operator. Increments the pointer by 1.
 
OffsetPtr operator++ (int) noexcept
 Postfix increment operator. Increments the pointer by 1.
 
OffsetPtr & operator-- (void) noexcept
 Prefix increment operator. Decrements the pointer by 1.
 
OffsetPtr operator-- (int) noexcept
 Postfix increment operator. Decrements the pointer by 1.
 
 operator bool () const noexcept
 Checks if the pointer is nullptr.
 
bool operator! () const noexcept
 Checks if the pointer is nullptr.
 

Static Public Member Functions

static OffsetPtr pointer_to (reference r) noexcept
 Creates a new OffsetPtr from a raw pointer.
 

Private Member Functions

template<class T2 , class P2 , class O2 , std::size_t A2>
 OffsetPtr (const OffsetPtr< T2, P2, O2, A2 > &r, static_cast_tag) noexcept
 Constructor to emulate static_cast operator.
 
template<class T2 , class P2 , class O2 , std::size_t A2>
 OffsetPtr (const OffsetPtr< T2, P2, O2, A2 > &r, const_cast_tag) noexcept
 Constructor to emulate const_cast operator.
 
template<class T2 , class P2 , class O2 , std::size_t A2>
 OffsetPtr (const OffsetPtr< T2, P2, O2, A2 > &r, dynamic_cast_tag) noexcept
 Constructor to emulate dynamic_cast operator.
 
template<class T2 , class P2 , class O2 , std::size_t A2>
 OffsetPtr (const OffsetPtr< T2, P2, O2, A2 > &r, reinterpret_cast_tag) noexcept
 Constructor to emulate reinterpret_cast operator.
 

Private Attributes

OffsetType mOffset = nullOffset
 

Static Private Attributes

static constexpr OffsetType nullOffset = 1
 

Friends

template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > static_pointer_cast (const OffsetPtr< T2, P2, O2, A2 > &r) noexcept
 Simulation of static_cast between pointers.
 
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > const_pointer_cast (const OffsetPtr< T2, P2, O2, A2 > &r) noexcept
 Simulation of const_cast between pointers.
 
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > dynamic_pointer_cast (const OffsetPtr< T2, P2, O2, A2 > &r) noexcept
 Simulation of dynamic_cast between pointers.
 
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > reinterpret_pointer_cast (const OffsetPtr< T2, P2, O2, A2 > &r) noexcept
 Simulation of reinterpret_cast between pointers.
 
OffsetPtr operator+ (difference_type diff, OffsetPtr right) noexcept
 
OffsetPtr operator+ (OffsetPtr left, difference_type diff) noexcept
 
OffsetPtr operator- (OffsetPtr left, difference_type diff) noexcept
 
OffsetPtr operator- (difference_type diff, OffsetPtr right) noexcept
 
difference_type operator- (const OffsetPtr &pt, const OffsetPtr &pt2) noexcept
 
bool operator== (const OffsetPtr &pt1, const OffsetPtr &pt2) noexcept
 
bool operator!= (const OffsetPtr &pt1, const OffsetPtr &pt2) noexcept
 Checks if two pointers point to the same object.
 
bool operator< (const OffsetPtr &pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator<.
 
bool operator<= (const OffsetPtr &pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator<=.
 
bool operator> (const OffsetPtr &pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator>.
 
bool operator>= (const OffsetPtr &pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator>=.
 
bool operator== (pointer pt1, const OffsetPtr &pt2) noexcept
 
bool operator!= (pointer pt1, const OffsetPtr &pt2) noexcept
 Checks if two pointers point to the same object.
 
bool operator< (pointer pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator<.
 
bool operator<= (pointer pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator<=.
 
bool operator> (pointer pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator>.
 
bool operator>= (pointer pt1, const OffsetPtr &pt2) noexcept
 Compares two pointers using operator>=.
 
bool operator== (const OffsetPtr &pt1, pointer pt2) noexcept
 
bool operator!= (const OffsetPtr &pt1, pointer pt2) noexcept
 Checks if two pointers point to the same object.
 
bool operator< (const OffsetPtr &pt1, pointer pt2) noexcept
 Compares two pointers using operator<.
 
bool operator<= (const OffsetPtr &pt1, pointer pt2) noexcept
 Compares two pointers using operator<=.
 
bool operator> (const OffsetPtr &pt1, pointer pt2) noexcept
 Compares two pointers using operator>.
 
bool operator>= (const OffsetPtr &pt1, pointer pt2) noexcept
 Compares two pointers using operator>=.
 
void swap (OffsetPtr &left, OffsetPtr &right) noexcept
 Swaps left and right pointers.
 

Detailed Description

template<typename PointedType, class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
class CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >

A special pointer that stores the pointer as an offset of the pointee to the OffsetPtr instance itself.

This can be used to store a pointer to an object in shared-memory or memory-mapped objects that are meant to be stored.

Member Typedef Documentation

◆ difference_type

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::difference_type = DifferenceType

◆ element_type

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::element_type = PointedType

◆ iterator_category

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::iterator_category = std::random_access_iterator_tag

◆ offset_type

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::offset_type = OffsetType

◆ pointer

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::pointer = PointedType*

◆ rebind

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class U >
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::rebind = OffsetPtr<U, DifferenceType, OffsetType, OffsetAlignment>

◆ reference

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::reference = typename std::add_lvalue_reference_t<PointedType>

◆ value_type

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
using CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::value_type = std::remove_cv_t<PointedType>

Constructor & Destructor Documentation

◆ OffsetPtr() [1/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( )
explicitdefaultnoexcept

◆ OffsetPtr() [2/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const pointer  ptr)
inlinenoexcept

Creates a new OffsetPtr from a raw pointer.

◆ OffsetPtr() [3/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<typename T >
requires std::is_convertible_v<T*, PointedType*>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( T  ptr)
inlinenoexcept

Creates a new OffsetPtr from a raw pointer.

◆ OffsetPtr() [4/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  ptr)
inlinenoexcept

Creates a new OffsetPtr by copying another.

◆ OffsetPtr() [5/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<typename T2 >
requires std::is_convertible_v<T2*, PointedType*>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const OffsetPtr< T2, DifferenceType, OffsetType, OffsetAlignment > &  ptr)
inlinenoexcept

Creates a new OffsetPtr by copying another.

◆ ~OffsetPtr()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::~OffsetPtr ( )
default

Default destructor.

◆ OffsetPtr() [6/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T2 , class P2 , class O2 , std::size_t A2>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const OffsetPtr< T2, P2, O2, A2 > &  r,
static_cast_tag   
)
inlineprivatenoexcept

Constructor to emulate static_cast operator.

◆ OffsetPtr() [7/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T2 , class P2 , class O2 , std::size_t A2>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const OffsetPtr< T2, P2, O2, A2 > &  r,
const_cast_tag   
)
inlineprivatenoexcept

Constructor to emulate const_cast operator.

◆ OffsetPtr() [8/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T2 , class P2 , class O2 , std::size_t A2>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const OffsetPtr< T2, P2, O2, A2 > &  r,
dynamic_cast_tag   
)
inlineprivatenoexcept

Constructor to emulate dynamic_cast operator.

◆ OffsetPtr() [9/9]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T2 , class P2 , class O2 , std::size_t A2>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::OffsetPtr ( const OffsetPtr< T2, P2, O2, A2 > &  r,
reinterpret_cast_tag   
)
inlineprivatenoexcept

Constructor to emulate reinterpret_cast operator.

Member Function Documentation

◆ get()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
pointer CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::get ( ) const
inlinenoexcept

Obtains raw pointer from offset.

◆ getOffset()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
offset_type CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::getOffset ( ) const
inlinenoexcept

Obtains the internal offset of the pointer.

◆ operator bool()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator bool ( ) const
inlineexplicitnoexcept

Checks if the pointer is nullptr.

If this method returns true, it is safe to call operator* or use the pointer returned by get().

◆ operator!()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator! ( ) const
inlinenoexcept

Checks if the pointer is nullptr.

◆ operator*()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
reference CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator* ( ) const
inlinenoexcept

Implements the dereferencing operator, if it is nullptr, behavior is undefined.

◆ operator++() [1/2]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator++ ( int  )
inlinenoexcept

Postfix increment operator. Increments the pointer by 1.

◆ operator++() [2/2]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator++ ( void  )
inlinenoexcept

Prefix increment operator. Increments the pointer by 1.

◆ operator+=()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator+= ( difference_type  offset)
inlinenoexcept

Increments the pointer by the given offset.

◆ operator--() [1/2]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator-- ( int  )
inlinenoexcept

Postfix increment operator. Decrements the pointer by 1.

◆ operator--() [2/2]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator-- ( void  )
inlinenoexcept

Prefix increment operator. Decrements the pointer by 1.

◆ operator-=()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator-= ( difference_type  offset)
inlinenoexcept

Decrements the pointer by the given offset.

◆ operator->()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
pointer CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator-> ( ) const
inlinenoexcept

Implements the pointer-like -> operator. It can return 0 pointer.

◆ operator=() [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  ptr)
inlinenoexcept

Assigns the OffsetPtr by copying another.

◆ operator=() [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T2 >
requires std::is_convertible_v<T2*, PointedType*>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator= ( const OffsetPtr< T2, DifferenceType, OffsetType, OffsetAlignment > &  ptr)
inlinenoexcept

Assigns the OffsetPtr by copying another.

◆ operator=() [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr & CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator= ( const pointer  from)
inlinenoexcept

Assigns the OffsetPtr from a raw pointer.

◆ operator[]()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
reference CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::operator[] ( difference_type  idx) const
inlinenoexcept

Implements the indexing operator.

◆ pointer_to()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
static OffsetPtr CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::pointer_to ( reference  r)
inlinestaticnoexcept

Creates a new OffsetPtr from a raw pointer.

Used for compatibility with std::pointer_traits.

◆ reset()

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
void CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::reset ( )
inlinenoexcept

Resets the pointer and sets it to nullptr.

Friends And Related Symbol Documentation

◆ const_pointer_cast

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > const_pointer_cast ( const OffsetPtr< T2, P2, O2, A2 > &  r)
friend

Simulation of const_cast between pointers.

◆ dynamic_pointer_cast

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > dynamic_pointer_cast ( const OffsetPtr< T2, P2, O2, A2 > &  r)
friend

Simulation of dynamic_cast between pointers.

◆ operator!= [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator!= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Checks if two pointers point to the same object.

◆ operator!= [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator!= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
pointer  pt2 
)
friend

Checks if two pointers point to the same object.

◆ operator!= [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator!= ( pointer  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Checks if two pointers point to the same object.

◆ operator+ [1/2]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr operator+ ( difference_type  diff,
OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >  right 
)
friend

◆ operator+ [2/2]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr operator+ ( OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >  left,
difference_type  diff 
)
friend

◆ operator- [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
difference_type operator- ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

◆ operator- [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr operator- ( difference_type  diff,
OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >  right 
)
friend

◆ operator- [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetPtr operator- ( OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >  left,
difference_type  diff 
)
friend

◆ operator< [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator< ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator<.

◆ operator< [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator< ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
pointer  pt2 
)
friend

Compares two pointers using operator<.

◆ operator< [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator< ( pointer  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator<.

◆ operator<= [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator<= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator<=.

◆ operator<= [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator<= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
pointer  pt2 
)
friend

Compares two pointers using operator<=.

◆ operator<= [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator<= ( pointer  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator<=.

◆ operator== [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator== ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

◆ operator== [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator== ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
pointer  pt2 
)
friend

◆ operator== [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator== ( pointer  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

◆ operator> [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator> ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator>.

◆ operator> [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator> ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
pointer  pt2 
)
friend

Compares two pointers using operator>.

◆ operator> [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator> ( pointer  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator>.

◆ operator>= [1/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator>= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator>=.

◆ operator>= [2/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator>= ( const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt1,
pointer  pt2 
)
friend

Compares two pointers using operator>=.

◆ operator>= [3/3]

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
bool operator>= ( pointer  pt1,
const OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  pt2 
)
friend

Compares two pointers using operator>=.

◆ reinterpret_pointer_cast

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > reinterpret_pointer_cast ( const OffsetPtr< T2, P2, O2, A2 > &  r)
friend

Simulation of reinterpret_cast between pointers.

◆ static_pointer_cast

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
template<class T1 , class P1 , class O1 , std::size_t A1, class T2 , class P2 , class O2 , std::size_t A2>
OffsetPtr< T1, P1, O1, A1 > static_pointer_cast ( const OffsetPtr< T2, P2, O2, A2 > &  r)
friend

Simulation of static_cast between pointers.

◆ swap

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
void swap ( OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  left,
OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment > &  right 
)
friend

Swaps left and right pointers.

Member Data Documentation

◆ mOffset

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
OffsetType CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::mOffset = nullOffset
private

◆ nullOffset

template<typename PointedType , class DifferenceType = std::ptrdiff_t, class OffsetType = std::intptr_t, std::size_t OffsetAlignment = alignof(OffsetType)>
constexpr OffsetType CeresEngine::OffsetPtr< PointedType, DifferenceType, OffsetType, OffsetAlignment >::nullOffset = 1
staticconstexprprivate
The documentation for this class was generated from the following file: