Pointer.h

/*********************************************************************** Author: Zihan Chen (vczh) Licensed under https://github.com/vczh-libraries/License ***********************************************************************/

#ifndef VCZH_POINTER

#define VCZH_POINTER

#include "Basic.h"

namespace

{

/*********************************************************************** ReferenceCounterOperator ***********************************************************************/

/// <summary>

/// The strategy class to create and delete the reference counter of an object.

/// For any object inherits from [T:vl.reflection.DescriptableObject], the reference counter is stored inside the object.

/// For any other object, the reference counter is allocated separately.

/// You can create your own strategy by adding a new partial specialization to this class.

/// </summary>

/// <typeparam name="T">

/// The type of the object.

/// </typeparam>

/// <typeparam name="Enabled">

/// [T:vl.Ptr`1] will always use [T:vl.YesType] as the second type parameter.

/// This parameter is useful when you want to do partial specialization in the SFINAE way.

/// </typeparam>

template

typename

Enabled

YesType

struct

ReferenceCounterOperator

{

/// <summary>Create the reference counter of an object.</summary>

/// <returns>The pointer to the reference counter.</returns>

/// <param name="reference">The object.</param>

static

__forceinline

volatile

vint

CreateCounter

(

reference

) {

return

new

vint

(

); }

/// <summary>Delete the reference counter from an object.</summary>

/// <param name="counter">The pointer to the reference counter.</param>

/// <param name="reference">The object.</param>

static

__forceinline

void

DeleteReference

(

volatile

vint

counter

void

reference

) {

delete

counter

;

delete

(

reference

; } };

/*********************************************************************** Ptr ***********************************************************************/

/// <summary>

/// A shared pointer.

/// It maintains a reference counter to the object.

/// When no [T:vl.Ptr`1] is referencing the object, the object will be deleted automatically.

/// </summary>

/// <remarks>

/// It is safe to convert the same pointer to an object to a shared pointer once.

/// If you do it multiple times, it depends on [T:vl.ReferenceCounterOperator`2].

/// For built-in strategies, only pointer to [T:vl.reflection.DescriptableObject] or its derived classes can be safely converted to a shared pointer for multiple times.

/// For any other object, it will crash on the destructor of [T:vl.Ptr`1].

/// </remarks>

/// <typeparam name="T">The type of the object.</typeparam>

template

typename

class

Ptr

{

template

typename

friend

class

Ptr

;

protected

typedef

void

Destructor

)(

volatile

vint

void

*);

volatile

vint

counter

nullptr

;

reference

nullptr

;

void

originalReference

nullptr

;

Destructor

originalDestructor

nullptr

;

void

SetEmptyNoIncDec

() {

counter

nullptr

;

reference

nullptr

;

originalReference

nullptr

;

originalDestructor

nullptr

; }

void

Inc

() {

(

counter

) {

INCRC(counter);

(

_InterlockedIncrement

((

volatile

long

*)(

counter

)));

} }

void

Dec

(

bool

deleteIfZero

true

) {

(

counter

) {

if (DECRC(counter) == 0)

((

_InterlockedDecrement

((

volatile

long

*)(

counter

))) ==

)

{

(

deleteIfZero

) {

originalDestructor

(

counter

originalReference

); }

SetEmptyNoIncDec

(); } } }

volatile

vint

Counter

()

const

{

return

counter

; }

Ptr

(

volatile

vint

_counter

_reference

void

_originalReference

Destructor

_originalDestructor

) :counter(

_counter

) , reference(

_reference

) , originalReference(

_originalReference

) , originalDestructor(

_originalDestructor

) {

Inc

(); }

public

/// <summary>Create a null pointer.</summary>

Ptr

() =

default

;

/// <summary>Convert a pointer to an object to a shared pointer.</summary>

/// <param name="pointer">The pointer to the object.</param>

Ptr

(

pointer

) {

(

pointer

) {

counter

ReferenceCounterOperator

>::

CreateCounter

(

pointer

);

reference

pointer

;

originalReference

pointer

;

originalDestructor

= &

ReferenceCounterOperator

>::

DeleteReference

;

Inc

(); } }

/// <summary>Copy a shared pointer.</summary>

/// <param name="pointer">The shared pointer to copy.</param>

Ptr

(

const

Ptr

pointer

) :counter(

pointer

counter

) , reference(

pointer

reference

) , originalReference(

pointer

originalReference

) , originalDestructor(

pointer

originalDestructor

) {

Inc

(); }

/// <summary>Move a shared pointer.</summary>

/// <param name="pointer">The shared pointer to Move.</param>

Ptr

(

Ptr

>&&

pointer

) :counter(

pointer

counter

) , reference(

pointer

reference

) , originalReference(

pointer

originalReference

) , originalDestructor(

pointer

originalDestructor

) {

pointer

SetEmptyNoIncDec

(); }

/// <summary>Cast a shared pointer implicitly by copying another shared pointer.</summary>

/// <typeparam name="C">The type of the object before casting.</typeparam>

/// <param name="pointer">The shared pointer to cast.</param>

template

typename

AcceptType

void

typename

PointerConvertable

>::

YesNoType

>::

Type

Ptr

(

const

Ptr

pointer

) {

(

auto

converted

pointer

Obj

()) {

counter

pointer

Counter

();

reference

converted

;

originalReference

pointer

originalReference

;

originalDestructor

pointer

originalDestructor

;

Inc

(); } }

/// <summary>Cast a shared pointer implicitly by moving another shared pointer.</summary>

/// <typeparam name="C">The type of the object before casting.</typeparam>

/// <param name="pointer">The shared pointer to cast.</param>

template

typename

AcceptType

void

typename

PointerConvertable

>::

YesNoType

>::

Type

Ptr

(

Ptr

>&&

pointer

) {

(

auto

converted

pointer

Obj

()) {

counter

pointer

Counter

();

reference

converted

;

originalReference

pointer

originalReference

;

originalDestructor

pointer

originalDestructor

;

pointer

SetEmptyNoIncDec

(); } }

Ptr

() {

Dec

(); }

/// <summary>

/// Detach the contained object from this shared pointer.

/// When no [T:vl.Ptr`1] is referencing to the object because of a call to Detach, the object will not be deleted.

/// </summary>

/// <returns>The detached object. Returns null if this shared pointer is empty.</returns>

Detach

() {

auto

detached

reference

;

Dec

(

false

);

return

detached

; }

/// <summary>Cast a shared pointer explicitly.</summary>

/// <typeparam name="C">The type of the object after casting.</typeparam>

/// <returns>The casted shared pointer. Returns null for empty shared pointer or a failed cast.</returns>

template

typename

Ptr

Cast

()

const

{

converted

dynamic_cast

*>(

reference

);

return

Ptr

>((

converted

counter

converted

originalReference

originalDestructor

); }

/// <summary>Replace the object inside this shared pointer.</summary>

/// <returns>The shared pointer itself.</returns>

/// <param name="pointer">The pointer to the new object.</param>

Ptr

operator

(

pointer

) {

Dec

();

(

pointer

) {

counter

ReferenceCounterOperator

>::

CreateCounter

(

pointer

);

reference

pointer

;

originalReference

pointer

;

originalDestructor

= &

ReferenceCounterOperator

>::

DeleteReference

;

Inc

(); }

else

{

SetEmptyNoIncDec

(); }

return

this

; }

/// <summary>Replace by copying another shared pointer.</summary>

/// <returns>The shared pointer itself.</returns>

/// <param name="pointer">The shared pointer to copy.</param>

Ptr

operator

(

const

Ptr

pointer

) {

(

this

!= &

pointer

) {

Dec

();

counter

pointer

counter

;

reference

pointer

reference

;

originalReference

pointer

originalReference

;

originalDestructor

pointer

originalDestructor

;

Inc

(); }

return

this

; }

/// <summary>Replace by moving another shared pointer.</summary>

/// <returns>The shared pointer itself.</returns>

/// <param name="pointer">The shared pointer to copy.</param>

Ptr

operator

(

Ptr

>&&

pointer

) {

(

this

!= &

pointer

) {

Dec

();

counter

pointer

counter

;

reference

pointer

reference

;

originalReference

pointer

originalReference

;

originalDestructor

pointer

originalDestructor

;

pointer

SetEmptyNoIncDec

(); }

return

this

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

Ptr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

Ptr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

Ptr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

Ptr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

Ptr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

Ptr

pointer

)

const

{

return

reference

pointer

reference

; }

/// <summary>Test if it is an empty shared pointer.</summary>

/// <returns>Returns true if it is non-null.</returns>

operator

bool

()

const

{

return

reference

; }

/// <summary>Get the pointer to the contained object.</summary>

/// <returns>The pointer to the contained object. Returns null for an empty shared pointer.</returns>

Obj

()

const

{

return

reference

; }

/// <summary>Get the pointer to the contained object.</summary>

/// <returns>The pointer to the contained object. Returns null for an empty shared pointer.</returns>

operator

()

const

{

return

reference

; } };

/*********************************************************************** ComPtr ***********************************************************************/

template

typename

class

ComPtr

{

protected

volatile

vint

counter

;

reference

;

void

Inc

() {

(

counter

) {

INCRC(counter);

(

_InterlockedIncrement

((

volatile

long

*)(

counter

)));

} }

void

Dec

() {

(

counter

) {

if(DECRC(counter)==0)

((

_InterlockedDecrement

((

volatile

long

*)(

counter

)))==

)

{

delete

counter

;

reference

->Release();

counter

;

reference

; } } }

volatile

vint

Counter

()

const

{

return

counter

; }

ComPtr

(

volatile

vint

_counter

_reference

) :counter(

_counter

) ,reference(

_reference

) {

Inc

(); }

public

ComPtr

() {

counter

;

reference

; }

ComPtr

(

pointer

) {

(

pointer

) {

counter

new

volatile

vint

(

);

reference

pointer

; }

else

{

counter

;

reference

; } }

ComPtr

(

const

ComPtr

pointer

) {

counter

pointer

counter

;

reference

pointer

reference

;

Inc

(); }

ComPtr

(

ComPtr

>&&

pointer

) {

counter

pointer

counter

;

reference

pointer

reference

;

pointer

counter

;

pointer

reference

; }

ComPtr

() {

Dec

(); }

ComPtr

operator

(

pointer

) {

Dec

();

(

pointer

) {

counter

new

vint

(

);

reference

pointer

; }

else

{

counter

;

reference

; }

return

this

; }

ComPtr

operator

(

const

ComPtr

pointer

) {

(

this

!=&

pointer

) {

Dec

();

counter

pointer

counter

;

reference

pointer

reference

;

Inc

(); }

return

this

; }

ComPtr

operator

(

ComPtr

>&&

pointer

) {

(

this

!=&

pointer

) {

Dec

();

counter

pointer

counter

;

reference

pointer

reference

;

pointer

counter

;

pointer

reference

; }

return

this

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

pointer

)

const

{

return

reference

pointer

; }

bool

operator

(

const

ComPtr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

ComPtr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

ComPtr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

ComPtr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

ComPtr

pointer

)

const

{

return

reference

pointer

reference

; }

bool

operator

(

const

ComPtr

pointer

)

const

{

return

reference

pointer

reference

; }

operator

bool

()

const

{

return

reference

; }

Obj

()

const

{

return

reference

; }

operator

()

const

{

return

reference

; } };

template

typename

...

TArgs

Ptr

MakePtr

(

TArgs

...

args

) {

return

new

(

args

...); }

/*********************************************************************** Traits ***********************************************************************/

template

typename

struct

KeyType

Ptr

>> {

typedef

Type

;

static

GetKeyValue

(

const

Ptr

key

) {

return

key

Obj

(); } };

template

typename

struct

POD

Ptr

>> {

static

const

bool

Result

false

; };

template

typename

struct

KeyType

ComPtr

>> {

typedef

Type

;

static

GetKeyValue

(

const

ComPtr

key

) {

return

key

Obj

(); } };

template

typename

struct

POD

ComPtr

>> {

static

const

bool

Result

false

; }; }

#endif