GuiTypeDescriptorBuilder.h

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

#ifndef VCZH_REFLECTION_GUITYPEDESCRIPTORBUILDER

#define VCZH_REFLECTION_GUITYPEDESCRIPTORBUILDER

#include "GuiTypeDescriptorPredefined.h"

namespace

{

namespace

collections

{

template

typename

class

ObservableList

; }

namespace

reflection

{

namespace

description

{

#ifndef VCZH_DEBUG_NO_REFLECTION

/*********************************************************************** TypeInfo ***********************************************************************/

#define DECL_TYPE_INFO(TYPENAME) template<>struct TypeInfo<TYPENAME>{ static const TypeInfoContent content; };

#define IMPL_VL_TYPE_INFO(TYPENAME) const TypeInfoContent TypeInfo<TYPENAME>::content = { L ## #TYPENAME, nullptr, TypeInfoContent::VlppType };

#define IMPL_CPP_TYPE_INFO(TYPENAME) const TypeInfoContent TypeInfo<TYPENAME>::content = { L ## #TYPENAME, nullptr, TypeInfoContent::CppType };

#define IMPL_TYPE_INFO_RENAME(TYPENAME, EXPECTEDNAME) const TypeInfoContent TypeInfo<TYPENAME>::content = { L ## #EXPECTEDNAME, L ## #TYPENAME, TypeInfoContent::Renamed };

struct

TypeInfoContent

{

enum

TypeInfoCppName

{

VlppType

// vl::<type-name>

CppType

// <type-name>

Renamed

// CppFullTypeName

};

const

wchar_t

typeName

;

const

wchar_t

cppFullTypeName

;

TypeInfoCppName

cppName

; };

template

typename

struct

TypeInfo

{ };

/// <summary>Get a registered type given a C++ type.</summary>

/// <returns>Returns the metadata class for this registered type.</returns>

/// <typeparam name="T">The C++ type to get the registered type.</typeparam>

/// <remarks>

/// Returning null means the type registration is declared but the type manager has not started.

/// Failing to compile means that the type registration is not declared.

/// See <see cref="Description`1"/> about how to register a type.

/// </remarks>

template

typename

ITypeDescriptor

GetTypeDescriptor

() {

static

vint

typeVersion

= -

;

static

ITypeDescriptor

cached

nullptr

;

(

auto

GetGlobalTypeManager

()) {

auto

currentVersion

GetTypeVersion

();

(

typeVersion

currentVersion

) {

cached

GetTypeDescriptor

(

TypeInfo

>::

content

.typeName); }

return

cached

; }

else

{

typeVersion

= -

;

return

nullptr

; } }

#endif

#ifndef VCZH_DEBUG_NO_REFLECTION

/*********************************************************************** TypeInfoImp ***********************************************************************/

class

TypeDescriptorTypeInfo

public

Object

public

ITypeInfo

{

protected

ITypeDescriptor

typeDescriptor

;

TypeInfoHint

hint

;

public

TypeDescriptorTypeInfo

(

ITypeDescriptor

_typeDescriptor

TypeInfoHint

_hint

);

TypeDescriptorTypeInfo

();

Decorator

GetDecorator

()

override

;

TypeInfoHint

GetHint

()

override

;

ITypeInfo

GetElementType

()

override

;

ITypeDescriptor

GetTypeDescriptor

()

override

;

vint

GetGenericArgumentCount

()

override

;

ITypeInfo

GetGenericArgument

(

vint

index

)

override

;

WString

GetTypeFriendlyName

()

override

; };

class

DecoratedTypeInfo

public

Object

public

ITypeInfo

{

protected

Ptr

ITypeInfo

elementType

;

public

DecoratedTypeInfo

(

Ptr

ITypeInfo

_elementType

);

DecoratedTypeInfo

();

TypeInfoHint

GetHint

()

override

;

ITypeInfo

GetElementType

()

override

;

ITypeDescriptor

GetTypeDescriptor

()

override

;

vint

GetGenericArgumentCount

()

override

;

ITypeInfo

GetGenericArgument

(

vint

index

)

override

; };

class

RawPtrTypeInfo

public

DecoratedTypeInfo

{

public

RawPtrTypeInfo

(

Ptr

ITypeInfo

_elementType

);

RawPtrTypeInfo

();

Decorator

GetDecorator

()

override

;

WString

GetTypeFriendlyName

()

override

; };

class

SharedPtrTypeInfo

public

DecoratedTypeInfo

{

public

SharedPtrTypeInfo

(

Ptr

ITypeInfo

_elementType

);

SharedPtrTypeInfo

();

Decorator

GetDecorator

()

override

;

WString

GetTypeFriendlyName

()

override

; };

class

NullableTypeInfo

public

DecoratedTypeInfo

{

public

NullableTypeInfo

(

Ptr

ITypeInfo

_elementType

);

NullableTypeInfo

();

Decorator

GetDecorator

()

override

;

WString

GetTypeFriendlyName

()

override

; };

class

GenericTypeInfo

public

DecoratedTypeInfo

{

protected

collections

List

Ptr

ITypeInfo

genericArguments

;

public

GenericTypeInfo

(

Ptr

ITypeInfo

_elementType

);

GenericTypeInfo

();

Decorator

GetDecorator

()

override

;

vint

GetGenericArgumentCount

()

override

;

ITypeInfo

GetGenericArgument

(

vint

index

)

override

;

WString

GetTypeFriendlyName

()

override

;

void

AddGenericArgument

(

Ptr

ITypeInfo

value

); };

#endif

#ifndef VCZH_DEBUG_NO_REFLECTION

/*********************************************************************** SerializableTypeDescriptor ***********************************************************************/

class

TypeDescriptorImplBase

public

Object

public

ITypeDescriptor

private

ITypeDescriptor

ICpp

{

private

TypeDescriptorFlags

typeDescriptorFlags

;

const

TypeInfoContent

typeInfoContent

;

WString

typeName

;

WString

cppFullTypeName

;

const

WString

GetFullName

()

override

;

protected

const

TypeInfoContent

GetTypeInfoContentInternal

();

public

TypeDescriptorImplBase

(

TypeDescriptorFlags

_typeDescriptorFlags

const

TypeInfoContent

_typeInfoContent

);

TypeDescriptorImplBase

();

ITypeDescriptor

ICpp

GetCpp

()

override

;

TypeDescriptorFlags

GetTypeDescriptorFlags

()

override

;

const

WString

GetTypeName

()

override

; };

class

ValueTypeDescriptorBase

public

TypeDescriptorImplBase

{

protected

bool

loaded

;

Ptr

IValueType

valueType

;

Ptr

IEnumType

enumType

;

Ptr

ISerializableType

serializableType

;

virtual

void

LoadInternal

();;

void

Load

();

public

ValueTypeDescriptorBase

(

TypeDescriptorFlags

_typeDescriptorFlags

const

TypeInfoContent

_typeInfoContent

);

ValueTypeDescriptorBase

();

bool

IsAggregatable

()

override

;

IValueType

GetValueType

()

override

;

IEnumType

GetEnumType

()

override

;

ISerializableType

GetSerializableType

()

override

;

vint

GetBaseTypeDescriptorCount

()

override

;

ITypeDescriptor

GetBaseTypeDescriptor

(

vint

index

)

override

;

bool

CanConvertTo

(

ITypeDescriptor

targetType

)

override

;

vint

GetPropertyCount

()

override

;

IPropertyInfo

GetProperty

(

vint

index

)

override

;

bool

IsPropertyExists

(

const

WString

name

bool

inheritable

)

override

;

IPropertyInfo

GetPropertyByName

(

const

WString

name

bool

inheritable

)

override

;

vint

GetEventCount

()

override

;

IEventInfo

GetEvent

(

vint

index

)

override

;

bool

IsEventExists

(

const

WString

name

bool

inheritable

)

override

;

IEventInfo

GetEventByName

(

const

WString

name

bool

inheritable

)

override

;

vint

GetMethodGroupCount

()

override

;

IMethodGroupInfo

GetMethodGroup

(

vint

index

)

override

;

bool

IsMethodGroupExists

(

const

WString

name

bool

inheritable

)

override

;

IMethodGroupInfo

GetMethodGroupByName

(

const

WString

name

bool

inheritable

)

override

;

IMethodGroupInfo

GetConstructorGroup

()

override

; };

template

typename

TypeDescriptorFlags

TDFlags

class

TypedValueTypeDescriptorBase

public

ValueTypeDescriptorBase

{

public

TypedValueTypeDescriptorBase

() :

ValueTypeDescriptorBase

(

TDFlags

, &

TypeInfo

>::

content

) { } };

/*********************************************************************** ParameterInfoImpl ***********************************************************************/

class

ParameterInfoImpl

public

Object

public

IParameterInfo

{

protected

IMethodInfo

ownerMethod

;

WString

name

;

Ptr

ITypeInfo

type

;

public

ParameterInfoImpl

(

IMethodInfo

_ownerMethod

const

WString

_name

Ptr

ITypeInfo

_type

);

ParameterInfoImpl

();

ITypeDescriptor

GetOwnerTypeDescriptor

()

override

;

const

WString

GetName

()

override

;

ITypeInfo

GetType

()

override

;

IMethodInfo

GetOwnerMethod

()

override

; };

/*********************************************************************** MethodInfoImpl ***********************************************************************/

class

MethodInfoImpl

public

Object

public

IMethodInfo

{

friend

class

PropertyInfoImpl

;

protected

IMethodGroupInfo

ownerMethodGroup

;

IPropertyInfo

ownerProperty

;

collections

List

Ptr

IParameterInfo

parameters

;

Ptr

ITypeInfo

returnInfo

;

bool

isStatic

;

virtual

Value

InvokeInternal

(

const

Value

thisObject

collections

Array

Value

arguments

;

virtual

Value

CreateFunctionProxyInternal

(

const

Value

thisObject

) =

;

public

MethodInfoImpl

(

IMethodGroupInfo

_ownerMethodGroup

Ptr

ITypeInfo

_return

bool

_isStatic

);

MethodInfoImpl

();

ITypeDescriptor

GetOwnerTypeDescriptor

()

override

;

IPropertyInfo

GetOwnerProperty

()

override

;

const

WString

GetName

()

override

;

IMethodGroupInfo

GetOwnerMethodGroup

()

override

;

vint

GetParameterCount

()

override

;

IParameterInfo

GetParameter

(

vint

index

)

override

;

ITypeInfo

GetReturn

()

override

;

bool

IsStatic

()

override

;

void

CheckArguments

(

collections

Array

Value

arguments

)

override

;

Value

Invoke

(

const

Value

thisObject

collections

Array

Value

arguments

)

override

;

Value

CreateFunctionProxy

(

const

Value

thisObject

)

override

;

bool

AddParameter

(

Ptr

IParameterInfo

parameter

);

bool

SetOwnerMethodgroup

(

IMethodGroupInfo

_ownerMethodGroup

); };

/*********************************************************************** MethodGroupInfoImpl ***********************************************************************/

class

MethodGroupInfoImpl

public

Object

public

IMethodGroupInfo

{

protected

ITypeDescriptor

ownerTypeDescriptor

;

WString

name

;

collections

List

Ptr

IMethodInfo

methods

;

public

MethodGroupInfoImpl

(

ITypeDescriptor

_ownerTypeDescriptor

const

WString

_name

);

MethodGroupInfoImpl

();

ITypeDescriptor

GetOwnerTypeDescriptor

()

override

;

const

WString

GetName

()

override

;

vint

GetMethodCount

()

override

;

IMethodInfo

GetMethod

(

vint

index

)

override

;

bool

AddMethod

(

Ptr

IMethodInfo

_method

); };

/*********************************************************************** EventInfoImpl ***********************************************************************/

class

EventInfoImpl

public

Object

public

IEventInfo

{

friend

class

PropertyInfoImpl

;

protected

ITypeDescriptor

ownerTypeDescriptor

;

collections

List

IPropertyInfo

observingProperties

;

WString

name

;

Ptr

ITypeInfo

handlerType

;

virtual

Ptr

IEventHandler

AttachInternal

(

DescriptableObject

thisObject

Ptr

IValueFunctionProxy

handler

;

virtual

bool

DetachInternal

(

DescriptableObject

thisObject

Ptr

IEventHandler

handler

;

virtual

void

InvokeInternal

(

DescriptableObject

thisObject

Ptr

IValueList

arguments

;

virtual

Ptr

ITypeInfo

GetHandlerTypeInternal

()=

;

public

EventInfoImpl

(

ITypeDescriptor

_ownerTypeDescriptor

const

WString

_name

);

EventInfoImpl

();

ITypeDescriptor

GetOwnerTypeDescriptor

()

override

;

const

WString

GetName

()

override

;

ITypeInfo

GetHandlerType

()

override

;

vint

GetObservingPropertyCount

()

override

;

IPropertyInfo

GetObservingProperty

(

vint

index

)

override

;

Ptr

IEventHandler

Attach

(

const

Value

thisObject

Ptr

IValueFunctionProxy

handler

)

override

;

bool

Detach

(

const

Value

thisObject

Ptr

IEventHandler

handler

)

override

;

void

Invoke

(

const

Value

thisObject

Ptr

IValueList

arguments

)

override

; };

/*********************************************************************** TypeDescriptorImpl ***********************************************************************/

class

PropertyInfoImpl

public

Object

public

IPropertyInfo

{

protected

ITypeDescriptor

ownerTypeDescriptor

;

WString

name

;

Ptr

ICpp

cpp

;

MethodInfoImpl

getter

;

MethodInfoImpl

setter

;

EventInfoImpl

valueChangedEvent

;

public

PropertyInfoImpl

(

ITypeDescriptor

_ownerTypeDescriptor

const

WString

_name

MethodInfoImpl

_getter

MethodInfoImpl

_setter

EventInfoImpl

_valueChangedEvent

);

PropertyInfoImpl

();

ITypeDescriptor

GetOwnerTypeDescriptor

()

override

;

const

WString

GetName

()

override

;

IPropertyInfo

ICpp

GetCpp

()

override

;

bool

IsReadable

()

override

;

bool

IsWritable

()

override

;

ITypeInfo

GetReturn

()

override

;

IMethodInfo

GetGetter

()

override

;

IMethodInfo

GetSetter

()

override

;

IEventInfo

GetValueChangedEvent

()

override

;

Value

GetValue

(

const

Value

thisObject

)

override

;

void

SetValue

(

Value

thisObject

const

Value

newValue

)

override

; };

class

PropertyInfoImpl_StaticCpp

public

PropertyInfoImpl

private

IPropertyInfo

ICpp

{

private

WString

referenceTemplate

;

const

WString

GetReferenceTemplate

()

override

;

public

PropertyInfoImpl_StaticCpp

(

ITypeDescriptor

_ownerTypeDescriptor

const

WString

_name

MethodInfoImpl

_getter

MethodInfoImpl

_setter

EventInfoImpl

_valueChangedEvent

const

WString

_referenceTemplate

);

PropertyInfoImpl_StaticCpp

();

IPropertyInfo

ICpp

GetCpp

()

override

; };

/*********************************************************************** FieldInfoImpl ***********************************************************************/

class

FieldInfoImpl

public

Object

public

IPropertyInfo

{

protected

ITypeDescriptor

ownerTypeDescriptor

;

Ptr

ITypeInfo

returnInfo

;

WString

name

;

virtual

Value

GetValueInternal

(

const

Value

thisObject

;

virtual

void

SetValueInternal

(

Value

thisObject

const

Value

newValue

;

public

FieldInfoImpl

(

ITypeDescriptor

_ownerTypeDescriptor

const

WString

_name

Ptr

ITypeInfo

_returnInfo

);

FieldInfoImpl

();

ITypeDescriptor

GetOwnerTypeDescriptor

()

override

;

const

WString

GetName

()

override

;

bool

IsReadable

()

override

;

bool

IsWritable

()

override

;

ITypeInfo

GetReturn

()

override

;

IMethodInfo

GetGetter

()

override

;

IMethodInfo

GetSetter

()

override

;

IEventInfo

GetValueChangedEvent

()

override

;

Value

GetValue

(

const

Value

thisObject

)

override

;

void

SetValue

(

Value

thisObject

const

Value

newValue

)

override

; };

/*********************************************************************** TypeDescriptorImpl ***********************************************************************/

class

TypeDescriptorImpl

public

TypeDescriptorImplBase

{

private

bool

loaded

;

collections

List

ITypeDescriptor

baseTypeDescriptors

;

collections

Dictionary

WString

Ptr

IPropertyInfo

properties

;

collections

Dictionary

WString

Ptr

IEventInfo

events

;

collections

Dictionary

WString

Ptr

MethodGroupInfoImpl

methodGroups

;

Ptr

MethodGroupInfoImpl

constructorGroup

;

protected

MethodGroupInfoImpl

PrepareMethodGroup

(

const

WString

name

);

MethodGroupInfoImpl

PrepareConstructorGroup

();

IPropertyInfo

AddProperty

(

Ptr

IPropertyInfo

value

);

IEventInfo

AddEvent

(

Ptr

IEventInfo

value

);

IMethodInfo

AddMethod

(

const

WString

name

Ptr

MethodInfoImpl

value

);

IMethodInfo

AddConstructor

(

Ptr

MethodInfoImpl

value

);

void

AddBaseType

(

ITypeDescriptor

value

);

virtual

void

LoadInternal

()=

;

void

Load

();

public

TypeDescriptorImpl

(

TypeDescriptorFlags

_typeDescriptorFlags

const

TypeInfoContent

_typeInfoContent

);

TypeDescriptorImpl

();

bool

IsAggregatable

()

override

;

IValueType

GetValueType

()

override

;

IEnumType

GetEnumType

()

override

;

ISerializableType

GetSerializableType

()

override

;

vint

GetBaseTypeDescriptorCount

()

override

;

ITypeDescriptor

GetBaseTypeDescriptor

(

vint

index

)

override

;

bool

CanConvertTo

(

ITypeDescriptor

targetType

)

override

;

vint

GetPropertyCount

()

override

;

IPropertyInfo

GetProperty

(

vint

index

)

override

;

bool

IsPropertyExists

(

const

WString

name

bool

inheritable

)

override

;

IPropertyInfo

GetPropertyByName

(

const

WString

name

bool

inheritable

)

override

;

vint

GetEventCount

()

override

;

IEventInfo

GetEvent

(

vint

index

)

override

;

bool

IsEventExists

(

const

WString

name

bool

inheritable

)

override

;

IEventInfo

GetEventByName

(

const

WString

name

bool

inheritable

)

override

;

vint

GetMethodGroupCount

()

override

;

IMethodGroupInfo

GetMethodGroup

(

vint

index

)

override

;

bool

IsMethodGroupExists

(

const

WString

name

bool

inheritable

)

override

;

IMethodGroupInfo

GetMethodGroupByName

(

const

WString

name

bool

inheritable

)

override

;

IMethodGroupInfo

GetConstructorGroup

()

override

; };

#endif

/*********************************************************************** TypeFlagTester ***********************************************************************/

enum

class

TypeFlags

{

NonGenericType

FunctionType

EnumerableType

ReadonlyListType

ListType

ObservableListType

ReadonlyDictionaryType

DictionaryType

, };

template

typename

struct

ValueRetriver

{

pointer

; };

template

typename

struct

ValueRetriver

&> {

pointer

; };

template

typename

TDerived

TypeFlags

Flag

struct

TypeFlagTester

{

static

const

TypeFlags

Result

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

FunctionType

> {

template

typename

static

void

Inherit

(

const

Func

source

){

return

{}; }

static

char

Inherit

(

void

source

){

return

{}; }

static

char

Inherit

(

const

void

source

){

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

))==

sizeof

(

void

*)?

TypeFlags

FunctionType

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

EnumerableType

> {

template

typename

static

void

Inherit

(

const

collections

LazyList

source

){

return

{}; }

static

char

Inherit

(

void

source

){

return

{}; }

static

char

Inherit

(

const

void

source

){

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

))==

sizeof

(

void

*)?

TypeFlags

EnumerableType

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

ReadonlyListType

> {

template

typename

static

void

Inherit

(

const

collections

IEnumerable

source

){

return

{}; }

static

char

Inherit

(

void

source

){

return

{}; }

static

char

Inherit

(

const

void

source

){

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

))==

sizeof

(

void

*)?

TypeFlags

ReadonlyListType

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

ListType

> {

template

typename

static

void

Inherit

(

collections

IEnumerable

source

){

return

{}; }

static

char

Inherit

(

void

source

){

return

{}; }

static

char

Inherit

(

const

void

source

){

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

))==

sizeof

(

void

*)?

TypeFlags

ListType

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

ObservableListType

> {

template

typename

static

void

Inherit

(

collections

ObservableList

source

) {

return

{}; }

static

char

Inherit

(

void

source

) {

return

{}; }

static

char

Inherit

(

const

void

source

) {

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

)) ==

sizeof

(

void

*) ?

TypeFlags

ObservableListType

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

ReadonlyDictionaryType

> {

template

typename

static

void

Inherit

(

const

collections

Dictionary

source

){

return

{}; }

static

char

Inherit

(

void

source

){

return

{}; }

static

char

Inherit

(

const

void

source

){

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

))==

sizeof

(

void

*)?

TypeFlags

ReadonlyDictionaryType

TypeFlags

NonGenericType

; };

template

typename

TDerived

struct

TypeFlagTester

TDerived

TypeFlags

DictionaryType

> {

template

typename

static

void

Inherit

(

collections

Dictionary

source

){

return

{}; }

static

char

Inherit

(

void

source

){

return

{}; }

static

char

Inherit

(

const

void

source

){

return

{}; }

static

const

TypeFlags

Result

sizeof

(

Inherit

(((

ValueRetriver

TDerived

>*)

)->

pointer

))==

sizeof

(

void

*)?

TypeFlags

DictionaryType

TypeFlags

NonGenericType

; };

/*********************************************************************** TypeFlagSelector ***********************************************************************/

template

typename

TypeFlags

Flag

struct

TypeFlagSelectorCase

{

static

const

TypeFlags

Result

TypeFlags

NonGenericType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

FunctionType

)> {

static

const

TypeFlags

Result

TypeFlags

FunctionType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

EnumerableType

vint

)

TypeFlags

ReadonlyListType

)> {

static

const

TypeFlags

Result

TypeFlags

EnumerableType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

EnumerableType

vint

)

TypeFlags

ListType

vint

)

TypeFlags

ReadonlyListType

)> {

static

const

TypeFlags

Result

TypeFlags

EnumerableType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

ListType

vint

)

TypeFlags

ReadonlyListType

)> {

static

const

TypeFlags

Result

TypeFlags

ListType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

ObservableListType

vint

)

TypeFlags

ListType

vint

)

TypeFlags

ReadonlyListType

)> {

static

const

TypeFlags

Result

TypeFlags

ObservableListType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

ReadonlyListType

)> {

static

const

TypeFlags

Result

TypeFlags

ReadonlyListType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

ListType

vint

)

TypeFlags

ReadonlyListType

vint

)

TypeFlags

DictionaryType

vint

)

TypeFlags

ReadonlyDictionaryType

)> {

static

const

TypeFlags

Result

TypeFlags

DictionaryType

; };

template

typename

struct

TypeFlagSelectorCase

, (

TypeFlags

)((

vint

)

TypeFlags

ReadonlyListType

vint

)

TypeFlags

ReadonlyDictionaryType

)> {

static

const

TypeFlags

Result

TypeFlags

ReadonlyDictionaryType

; };

template

typename

struct

TypeFlagSelector

{

static

const

TypeFlags

Result

TypeFlagSelectorCase

, (

TypeFlags

) ( (

vint

)

TypeFlagTester

TypeFlags

FunctionType

>::

Result

| (

vint

)

TypeFlagTester

TypeFlags

EnumerableType

>::

Result

| (

vint

)

TypeFlagTester

TypeFlags

ReadonlyListType

>::

Result

| (

vint

)

TypeFlagTester

TypeFlags

ListType

>::

Result

| (

vint

)

TypeFlagTester

TypeFlags

ObservableListType

>::

Result

| (

vint

)

TypeFlagTester

TypeFlags

ReadonlyDictionaryType

>::

Result

| (

vint

)

TypeFlagTester

TypeFlags

DictionaryType

>::

Result

) >::

Result

; };

/*********************************************************************** TypeHintTester ***********************************************************************/

template

typename

struct

TypeHintTester

{

static

const

TypeInfoHint

Result

TypeInfoHint

Normal

; };

template

TypeFlags

Flags

struct

TypeHintTesterForReference

{

static

const

TypeInfoHint

Result

TypeInfoHint

NativeCollectionReference

; };

template

struct

TypeHintTesterForReference

TypeFlags

NonGenericType

> {

static

const

TypeInfoHint

Result

TypeInfoHint

Normal

; };

template

struct

TypeHintTesterForReference

TypeFlags

FunctionType

> {

static

const

TypeInfoHint

Result

TypeInfoHint

Normal

; };

template

typename

struct

TypeHintTester

*> {

static

const

TypeInfoHint

Result

TypeHintTester

>::

Result

; };

template

typename

struct

TypeHintTester

&> {

static

const

TypeInfoHint

Result

TypeHintTester

>::

Result

TypeInfoHint

Normal

TypeHintTesterForReference

TypeFlagSelector

&>::

Result

>::

Result

TypeHintTester

>::

Result

; };

template

typename

struct

TypeHintTester

const

> {

static

const

TypeInfoHint

Result

TypeHintTester

>::

Result

; };

template

typename

struct

TypeHintTester

collections

LazyList

>> {

static

const

TypeInfoHint

Result

TypeInfoHint

LazyList

; };

template

typename

struct

TypeHintTester

collections

Array

>> {

static

const

TypeInfoHint

Result

TypeInfoHint

Array

; };

template

typename

struct

TypeHintTester

collections

List

>> {

static

const

TypeInfoHint

Result

TypeInfoHint

List

; };

template

typename

struct

TypeHintTester

collections

SortedList

>> {

static

const

TypeInfoHint

Result

TypeInfoHint

SortedList

; };

template

typename

struct

TypeHintTester

collections

ObservableList

>> {

static

const

TypeInfoHint

Result

TypeInfoHint

ObservableList

; };

template

typename

struct

TypeHintTester

collections

Dictionary

>> {

static

const

TypeInfoHint

Result

TypeInfoHint

Dictionary

; };

/*********************************************************************** TypeInfoRetriver ***********************************************************************/

template

typename

TypeFlags

Flag

struct

DetailTypeInfoRetriver

{

static

const

ITypeInfo

Decorator

ITypeInfo

TypeDescriptor

;

typedef

void

Type

;

typedef

void

TempValueType

;

typedef

void

ResultReferenceType

;

typedef

void

ResultNonReferenceType

; };

template

typename

struct

TypeInfoRetriver

{

static

const

TypeFlags

TypeFlag

TypeFlagSelector

>::

Result

;

static

const

TypeInfoHint

Hint

TypeHintTester

>::

Result

;

static

const

ITypeInfo

Decorator

DetailTypeInfoRetriver

TypeFlag

>::

Decorator

;

typedef

typename

DetailTypeInfoRetriver

TypeFlag

>::

Type

;

typedef

typename

DetailTypeInfoRetriver

TypeFlag

>::

TempValueType

;

typedef

typename

DetailTypeInfoRetriver

TypeFlag

>::

ResultReferenceType

;

typedef

typename

DetailTypeInfoRetriver

TypeFlag

>::

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

() {

return

DetailTypeInfoRetriver

typename

RemoveCVR

>::

Type

TypeFlag

>::

CreateTypeInfo

(

Hint

); }

#endif

};

/*********************************************************************** TypeInfoRetriver Helper Functions (BoxValue, UnboxValue) ***********************************************************************/

template

typename

ITypeInfo

Decorator

struct

ValueAccessor

{ };

/// <summary>Box an reflectable object. Its type cannot be generic.</summary>

/// <returns>The boxed value.</returns>

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

/// <param name="object">The object to box.</param>

/// <param name="typeDescriptor">The type descriptor of the object (optional).</param>

template

typename

Value

BoxValue

(

const

object

ITypeDescriptor

typeDescriptor

) {

using

Type

typename

RemoveCVR

>::

Type

;

return

ValueAccessor

Type

TypeInfoRetriver

Type

>::

Decorator

>::

BoxValue

(

object

typeDescriptor

); }

/// <summary>Unbox a reflectable object. Its type cannot be generic.</summary>

/// <returns>The unboxed object.</returns>

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

/// <param name="value">The value to unbox.</param>

/// <param name="typeDescriptor">The type descriptor of the object (optional).</param>

/// <param name="valueName">The name of the object to provide a friendly exception message if the conversion is failed (optional).</param>

template

typename

UnboxValue

(

const

Value

value

ITypeDescriptor

typeDescriptor

const

WString

valueName

L"value"

) {

using

Type

typename

RemoveCVR

>::

Type

;

return

ValueAccessor

Type

TypeInfoRetriver

Type

>::

Decorator

>::

UnboxValue

(

value

typeDescriptor

valueName

); }

/*********************************************************************** TypeInfoRetriver Helper Functions (UnboxParameter) ***********************************************************************/

template

typename

TypeFlags

Flag

struct

ParameterAccessor

{ };

/// <summary>Box an reflectable object. It supports generic types such as containers, functions (should be Func<T>), etc.</summary>

/// <returns>The boxed value.</returns>

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

/// <param name="object">The object to box.</param>

/// <param name="typeDescriptor">The type descriptor of the object (optional).</param>

template

typename

Value

BoxParameter

(

typename

TypeInfoRetriver

>::

ResultReferenceType

object

ITypeDescriptor

typeDescriptor

) {

return

ParameterAccessor

typename

TypeInfoRetriver

>::

ResultNonReferenceType

TypeInfoRetriver

>::

TypeFlag

>::

BoxParameter

(

object

typeDescriptor

); }

/// <summary>Box an reflectable object. It supports generic types such as containers, functions (should be Func<T>), etc.</summary>

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

/// <param name="value">The value to unbox.</param>

/// <param name="result">The unboxed object.</param>

/// <param name="typeDescriptor">The type descriptor of the object (optional).</param>

/// <param name="valueName">The name of the object to provide a friendly exception message if the conversion is failed (optional).</param>

template

typename

void

UnboxParameter

(

const

Value

value

result

ITypeDescriptor

typeDescriptor

const

WString

valueName

L"value"

) {

ParameterAccessor

TypeInfoRetriver

>::

TypeFlag

>::

UnboxParameter

(

value

result

typeDescriptor

valueName

); }

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

/*********************************************************************** Value_xs ***********************************************************************/

class

Value_xs

{

protected

collections

Array

Value

arguments

;

public

Value_xs

() { }

template

typename

Value_xs

operator

(

value

) {

arguments

Resize

(

arguments

Count

() +

);

arguments

[

arguments

Count

() -

]

BoxParameter

value

);

return

this

; }

template

typename

Value_xs

operator

(

const

value

) {

arguments

Resize

(

arguments

Count

() +

);

arguments

[

arguments

Count

() -

]

BoxParameter

const

value

);

return

this

; }

Value_xs

operator

(

const

Value

value

) {

arguments

Resize

(

arguments

Count

()+

);

arguments

[

arguments

Count

()-

]

value

;

return

this

; }

operator

collections

Array

Value

>&() {

return

arguments

; } };

/*********************************************************************** CustomFieldInfoImpl ***********************************************************************/

template

typename

TClass

typename

TField

class

CustomFieldInfoImpl

public

FieldInfoImpl

{

protected

TField

TClass

::*

fieldRef

;

Value

GetValueInternal

(

const

Value

thisObject

)

override

{

TClass

object

UnboxValue

TClass

*>(

thisObject

);

(

object

) {

return

BoxParameter

TField

object

->*

fieldRef

GetReturn

()->

GetTypeDescriptor

()); }

return

Value

(); }

void

SetValueInternal

(

Value

thisObject

const

Value

newValue

)

override

{

TClass

object

UnboxValue

TClass

*>(

thisObject

);

(

object

) {

UnboxParameter

TField

newValue

object

->*

fieldRef

GetReturn

()->

GetTypeDescriptor

(),

L"newValue"

); } }

public

CustomFieldInfoImpl

(

ITypeDescriptor

_ownerTypeDescriptor

const

WString

_name

TField

TClass

::*

_fieldRef

) :

FieldInfoImpl

(

_ownerTypeDescriptor

_name

TypeInfoRetriver

TField

>::

CreateTypeInfo

()) , fieldRef(

_fieldRef

) { }

IPropertyInfo

ICpp

GetCpp

()

override

{

return

nullptr

; } };

#endif

/*********************************************************************** PrimitiveTypeDescriptor ***********************************************************************/

#ifndef VCZH_DEBUG_NO_REFLECTION

template

typename

class

SerializableValueType

public

Object

public

virtual

IValueType

{

public

Value

CreateDefault

()

override

{

return

BoxValue

TypedValueSerializerProvider

>::

GetDefaultValue

()); }

IBoxedValue

CompareResult

Compare

(

const

Value

const

Value

)

override

{

auto

UnboxValue

);

auto

UnboxValue

);

return

TypedValueSerializerProvider

>::

Compare

(

); } };

template

typename

class

SerializableType

public

Object

public

virtual

ISerializableType

{

public

bool

Serialize

(

const

Value

input

WString

output

)

override

{

return

TypedValueSerializerProvider

>::

Serialize

(

UnboxValue

input

output

); }

bool

Deserialize

(

const

WString

input

Value

output

)

override

{

value

;

TypedValueSerializerProvider

>::

Deserialize

(

input

value

)) {

return

false

; }

output

BoxValue

value

);

return

true

; } };

#endif

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

template

typename

class

PrimitiveTypeDescriptor

public

TypedValueTypeDescriptorBase

TypeDescriptorFlags

Primitive

> {

protected

void

LoadInternal

()

override

{

this

valueType

new

SerializableValueType

>();

this

serializableType

new

SerializableType

>(); } };

/*********************************************************************** EnumTypeDescriptor ***********************************************************************/

template

typename

class

EnumValueType

public

Object

public

virtual

IValueType

{

public

Value

CreateDefault

()

override

{

return

BoxValue

static_cast

)); }

IBoxedValue

CompareResult

Compare

(

const

Value

const

Value

)

override

{

auto

static_cast

vuint64_t

UnboxValue

));

auto

static_cast

vuint64_t

UnboxValue

));

(

)

return

IBoxedValue

Smaller

;

(

)

return

IBoxedValue

Greater

;

return

IBoxedValue

Equal

; } };

template

typename

bool

Flag

class

EnumType

public

Object

public

virtual

IEnumType

{

protected

collections

Dictionary

WString

candidates

;

public

void

AddItem

(

WString

name

value

) {

candidates

Add

(

name

value

); }

bool

IsFlagEnum

()

override

{

return

Flag

; }

vint

GetItemCount

()

override

{

return

candidates

Count

(); }

WString

GetItemName

(

vint

index

)

override

{

(

index

candidates

Count

()) {

return

L""

; }

return

candidates

Keys

()

[

index

]; }

vuint64_t

GetItemValue

(

vint

index

)

override

{

(

index

candidates

Count

()) {

return

; }

return

static_cast

vuint64_t

candidates

Values

()

[

index

]); }

vint

IndexOfItem

(

WString

name

)

override

{

return

candidates

Keys

().

IndexOf

(

name

); }

Value

ToEnum

(

vuint64_t

value

)

override

{

return

BoxValue

static_cast

value

)); }

vuint64_t

FromEnum

(

const

Value

value

)

override

{

return

static_cast

vuint64_t

UnboxValue

value

)); } };

template

typename

TypeDescriptorFlags

TDFlags

class

EnumTypeDescriptor

public

TypedValueTypeDescriptorBase

TDFlags

> {

using

TEnumType

EnumType

TDFlags

TypeDescriptorFlags

FlagEnum

protected

Ptr

TEnumType

enumType

;

void

LoadInternal

()

override

{

this

enumType

new

TEnumType

;

this

valueType

new

EnumValueType

>();

TypedValueTypeDescriptorBase

TDFlags

>::

enumType

; } };

/*********************************************************************** StructTypeDescriptor ***********************************************************************/

template

typename

class

StructValueType

public

Object

public

virtual

IValueType

{

public

Value

CreateDefault

()

override

{

return

BoxValue

{}); }

IBoxedValue

CompareResult

Compare

(

const

Value

const

Value

)

override

{

return

IBoxedValue

NotComparable

; } };

template

typename

TypeDescriptorFlags

TDFlags

class

StructTypeDescriptor

public

TypedValueTypeDescriptorBase

TDFlags

> {

protected

template

typename

TField

class

StructFieldInfo

public

FieldInfoImpl

{

protected

TField

::*

field

;

Value

GetValueInternal

(

const

Value

thisObject

)

override

{

auto

structValue

thisObject

GetBoxedValue

().

Cast

IValueType

TypedBox

>>();

structValue

) {

throw

ArgumentTypeMismtatchException

(

L"thisObject"

GetOwnerTypeDescriptor

(),

Value

BoxedValue

thisObject

); }

return

BoxValue

TField

structValue

value

field

); }

void

SetValueInternal

(

Value

thisObject

const

Value

newValue

)

override

{

auto

structValue

thisObject

GetBoxedValue

().

Cast

IValueType

TypedBox

>>();

structValue

) {

throw

ArgumentTypeMismtatchException

(

L"thisObject"

GetOwnerTypeDescriptor

(),

Value

BoxedValue

thisObject

); } (

structValue

value

field

) =

UnboxValue

TField

newValue

); }

public

StructFieldInfo

(

ITypeDescriptor

_ownerTypeDescriptor

TField

::*

_field

const

WString

_name

) :field(

_field

) ,

FieldInfoImpl

(

_ownerTypeDescriptor

_name

TypeInfoRetriver

TField

>::

CreateTypeInfo

()) { }

IPropertyInfo

ICpp

GetCpp

()

override

{

return

nullptr

; } };

protected

collections

Dictionary

WString

Ptr

IPropertyInfo

fields

;

public

StructTypeDescriptor

() {

this

valueType

new

StructValueType

>(); }

vint

GetPropertyCount

()

override

{

this

Load

();

return

fields

Count

(); }

IPropertyInfo

GetProperty

(

vint

index

)

override

{

this

Load

();

(

index

fields

Count

()) {

return

nullptr

; }

return

fields

Values

()

[

index

Obj

(); }

bool

IsPropertyExists

(

const

WString

name

bool

inheritable

)

override

{

this

Load

();

return

fields

Keys

().

Contains

(

name

); }

IPropertyInfo

GetPropertyByName

(

const

WString

name

bool

inheritable

)

override

{

this

Load

();

vint

index

fields

Keys

().

IndexOf

(

name

);

(

index

== -

)

return

nullptr

;

return

fields

Values

()

[

index

Obj

(); } };

#endif

} } }

#endif