WfLibraryCppHelper.h

/*********************************************************************** Vczh Library++ 3.0 Developer: Zihan Chen(vczh) Framework::Reflection Interfaces: ***********************************************************************/

#ifndef VCZH_WORKFLOW_LIBRARY_CPPLIBRARY

#define VCZH_WORKFLOW_LIBRARY_CPPLIBRARY

#include <VlppReflection.h>

namespace

{

namespace

__vwsn

{

template

typename

struct

RunOnExit

{

function

;

RunOnExit

(

_function

) :function(

_function

) { }

RunOnExit

() {

function

operator

()(); } };

template

typename

This

(

thisValue

) {

CHECK_ERROR(thisValue != nullptr, L"The this pointer cannot be null.");

{

(!(

thisValue

nullptr

))

throw

Error

(

L"The this pointer cannot be null."

);}

while

(

);

return

thisValue

; }

template

typename

Ensure

(

pointer

) {

CHECK_ERROR(pointer != nullptr, L"The pointer cannot be null.");

{

(!(

pointer

nullptr

))

throw

Error

(

L"The pointer cannot be null."

);}

while

(

);

return

pointer

; }

template

typename

Ptr

Ensure

(

Ptr

pointer

) {

CHECK_ERROR(pointer != nullptr, L"The pointer cannot be null.");

{

(!(

pointer

nullptr

))

throw

Error

(

L"The pointer cannot be null."

);}

while

(

);

return

pointer

; }

template

typename

Ptr

Ensure

(

Ptr

>&&

pointer

) {

CHECK_ERROR(pointer != nullptr, L"The pointer cannot be null.");

{

(!(

pointer

nullptr

))

throw

Error

(

L"The pointer cannot be null."

);}

while

(

);

return

MoveValue

(

pointer

); }

template

typename

Nullable

Ensure

(

Nullable

>&&

nullable

) {

CHECK_ERROR(nullable, L"The pointer cannot be null.");

{

(!(

nullable

))

throw

Error

(

L"The pointer cannot be null."

);}

while

(

);

return

MoveValue

(

nullable

); }

template

typename

Nullable

Ensure

(

Nullable

nullable

) {

CHECK_ERROR(nullable, L"The pointer cannot be null.");

{

(!(

nullable

))

throw

Error

(

L"The pointer cannot be null."

);}

while

(

);

return

nullable

; }

template

typename

WString

ToString

(

const

value

) {

using

Type

typename

RemoveCVR

>::

Type

;

WString

str

;

CHECK_ERROR(reflection::description::TypedValueSerializerProvider<T>::Serialize(value, str), L"Failed to serialize.");

{

(!(

reflection

description

TypedValueSerializerProvider

>::

Serialize

(

value

str

)))

throw

Error

(

L"Failed to serialize."

);}

while

(

);

return

str

; }

template

typename

Parse

(

const

WString

str

) {

using

Type

typename

RemoveCVR

>::

Type

;

value

;

CHECK_ERROR(reflection::description::TypedValueSerializerProvider<T>::Deserialize(str, value), L"Failed to serialize.");

{

(!(

reflection

description

TypedValueSerializerProvider

>::

Deserialize

(

str

value

)))

throw

Error

(

L"Failed to serialize."

);}

while

(

);

return

value

; }

template

typename

TTo

typename

TFrom

struct

NullableCastHelper

{

static

Nullable

TTo

Cast

(

Nullable

TFrom

nullable

) {

return

Nullable

TTo

static_cast

TTo

nullable

Value

())); } };

template

typename

TFrom

struct

NullableCastHelper

WString

TFrom

> {

static

Nullable

WString

Cast

(

Nullable

TFrom

nullable

) {

return

Nullable

WString

ToString

(

nullable

Value

())); } };

template

typename

TTo

struct

NullableCastHelper

TTo

WString

> {

static

Nullable

TTo

Cast

(

Nullable

WString

nullable

) {

return

Nullable

TTo

Parse

TTo

nullable

Value

())); } };

template

typename

TTo

typename

TFrom

Nullable

TTo

NullableCast

(

Nullable

TFrom

nullable

) {

nullable

)

return

Nullable

TTo

>();

return

NullableCastHelper

TTo

TFrom

>::

Cast

(

nullable

); }

template

typename

TTo

typename

TFrom

TTo

RawPtrCast

(

TFrom

pointer

) {

pointer

)

return

nullptr

;

return

pointer

template

SafeAggregationCast<

TTo

>(); }

template

typename

TTo

typename

TFrom

Ptr

TTo

SharedPtrCast

(

TFrom

pointer

) {

pointer

)

return

nullptr

;

return

pointer

template

SafeAggregationCast<

TTo

>(); }

template

typename

reflection

description

Value

Box

(

const

value

) {

using

Type

typename

RemoveCVR

>::

Type

;

return

reflection

description

BoxParameter

Type

const_cast

&>(

value

)); }

template

typename

Unbox

(

const

reflection

description

Value

value

) {

using

Type

typename

RemoveCVR

>::

Type

;

result

;

reflection

description

UnboxParameter

Type

value

result

);

return

result

; }

template

typename

struct

UnboxWeakHelper

{ };

template

typename

struct

UnboxWeakHelper

*> {

static

Unbox

(

const

reflection

description

Value

value

) {

(

value

IsNull

())

return

nullptr

;

return

value

GetRawPtr

()->

SafeAggregationCast

>(); } };

template

typename

struct

UnboxWeakHelper

Ptr

>> {

static

Ptr

Unbox

(

const

reflection

description

Value

value

) {

(

value

IsNull

())

return

nullptr

;

return

value

GetRawPtr

()->

SafeAggregationCast

>(); } };

template

typename

struct

UnboxWeakHelper

Nullable

>> {

static

Nullable

Unbox

(

const

reflection

description

Value

value

) {

(

value

IsNull

())

return

Nullable

>();

auto

boxed

value

GetBoxedValue

().

Cast

reflection

description

IValueType

TypedBox

>>();

boxed

)

return

Nullable

>();

return

Nullable

boxed

value

); } };

template

typename

UnboxWeak

(

const

reflection

description

Value

value

) {

using

Type

typename

RemoveCVR

>::

Type

;

return

UnboxWeakHelper

Type

>::

Unbox

(

value

); }

template

typename

collections

LazyList

Range

(

begin

end

) {

return

collections

Range

begin

end

begin

); }

template

typename

bool

InSet

(

const

value

const

collections

LazyList

collection

) {

return

collection

Any

([&](

const

element

) {

return

element

value

; }); }

template

typename

bool

InSet

(

const

value

Ptr

reflection

description

IValueReadonlyList

collection

) {

return

InSet

value

reflection

description

GetLazyList

collection

)); }

template

typename

Ptr

UnboxCollection

(

const

value

) {

auto

boxedValue

reflection

description

BoxParameter

const_cast

&>(

value

));

Ptr

result

;

reflection

description

UnboxParameter

Ptr

>>(

boxedValue

result

);

return

result

; }

template

typename

Ptr

UnboxCollection

(

const

collections

LazyList

value

) {

auto

boxedValue

reflection

description

BoxParameter

collections

LazyList

>>(

const_cast

collections

LazyList

>&>(

value

));

Ptr

result

;

reflection

description

UnboxParameter

Ptr

>>(

boxedValue

result

);

return

result

; }

struct

CreateList

{

using

IValueList

reflection

description

IValueList

;

Ptr

IValueList

list

;

CreateList

();

CreateList

(

Ptr

IValueList

_list

);

template

typename

CreateList

Add

(

const

value

) {

list

Add

(

Box

(

value

));

return

{

list

}; } };

struct

CreateObservableList

{

using

IValueObservableList

reflection

description

IValueObservableList

;

Ptr

IValueObservableList

list

;

CreateObservableList

();

CreateObservableList

(

Ptr

IValueObservableList

_list

);

template

typename

CreateObservableList

Add

(

const

value

) {

list

Add

(

Box

(

value

));

return

{

list

}; } };

struct

CreateDictionary

{

using

IValueDictionary

reflection

description

IValueDictionary

;

Ptr

IValueDictionary

dictionary

;

CreateDictionary

();

CreateDictionary

(

Ptr

IValueDictionary

_dictionary

);

template

typename

CreateDictionary

Add

(

const

key

const

value

) {

dictionary

Set

(

Box

(

key

Box

(

value

));

return

{

dictionary

}; } };

template

typename

struct

EventHelper

{ };

template

typename

Ptr

reflection

description

IEventHandler

EventAttach

(

typename

EventHelper

>::Handler

handler

) {

return

EventHelper

>::

Attach

(

handler

); }

template

typename

bool

EventDetach

(

Ptr

reflection

description

IEventHandler

handler

) {

return

EventHelper

>::

Detach

(

handler

); }

template

typename

decltype

(

auto

)

EventInvoke

(

) {

return

EventHelper

>::

Invoke

(

); }

template

typename

...

TArgs

struct

EventHelper

Event

void

(

TArgs

...)>> {

using

Handler

const

Func

void

(

TArgs

...)>&;

class

EventHandlerImpl

public

Object

public

reflection

description

IEventHandler

{

public

Ptr

EventHandler

handler

;

EventHandlerImpl

(

Ptr

EventHandler

_handler

) :handler(

_handler

) { }

bool

IsAttached

()

override

{

return

handler

IsAttached

(); } };

static

Ptr

reflection

description

IEventHandler

Attach

(

Event

void

(

TArgs

...)>&

Handler

handler

) {

return

MakePtr

EventHandlerImpl

Add

(

handler

)); }

static

bool

Detach

(

Event

void

(

TArgs

...)>&

Ptr

reflection

description

IEventHandler

handler

) {

auto

impl

handler

Cast

EventHandlerImpl

>();

impl

)

return

false

;

return

Remove

(

impl

handler

); }

static

Event

void

(

TArgs

...)>&

Invoke

(

Event

void

(

TArgs

...)>&

) {

return

; } }; } }

#endif