GuiTypeDescriptorBuilder

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

#ifndef VCZH_REFLECTION_GUITYPEDESCRIPTORBUILDER_CONTAINER

#define VCZH_REFLECTION_GUITYPEDESCRIPTORBUILDER_CONTAINER

#include "GuiTypeDescriptorBuilder.h"

namespace

{

namespace

reflection

{

namespace

description

{

/*********************************************************************** Enumerable Wrappers ***********************************************************************/

template

typename

class

TypedEnumerator

public

Object

public

collections

IEnumerator

> {

private

Ptr

IValueEnumerable

enumerable

;

Ptr

IValueEnumerator

enumerator

;

vint

index

;

value

;

public

TypedEnumerator

(

Ptr

IValueEnumerable

_enumerable

vint

_index

const

_value

) :enumerable(

_enumerable

) ,index(

_index

) ,value(

_value

) {

enumerator

enumerable

CreateEnumerator

();

vint

current

;

while

(

current

++<

index

) {

enumerator

(); } }

TypedEnumerator

(

Ptr

IValueEnumerable

_enumerable

) :enumerable(

_enumerable

) ,index(-

) {

Reset

(); }

collections

IEnumerator

Clone

()

const

override

{

return

new

TypedEnumerator

enumerable

index

value

); }

const

Current

()

const

override

{

return

value

; }

vint

Index

()

const

override

{

return

index

; }

bool

()

override

{

(

enumerator

()) {

index

++;

value

UnboxValue

enumerator

GetCurrent

());

return

true

; }

else

{

return

false

; } }

void

Reset

()

override

{

index

;

enumerator

enumerable

CreateEnumerator

(); } };

/// <summary>Convert a reflectable container to a lazy list to the known element type.</summary>

/// <returns>The created lazy list.</returns>

/// <typeparam name="T">The expected element type.</typeparam>

/// <param name="value">The reflectable container.</param>

template

typename

collections

LazyList

GetLazyList

(

Ptr

IValueEnumerable

value

) {

return

collections

LazyList

new

TypedEnumerator

value

)); }

/// <summary>Convert a reflectable container to a lazy list to the known element type.</summary>

/// <returns>The created lazy list.</returns>

/// <typeparam name="T">The expected element type.</typeparam>

/// <param name="value">The reflectable container.</param>

template

typename

collections

LazyList

GetLazyList

(

Ptr

IValueReadonlyList

value

) {

return

collections

Range

vint

value

GetCount

()) .

Select

([value](

vint

) {

return

UnboxValue

value

Get

(

)); }); }

/// <summary>Convert a reflectable container to a lazy list to the known element type.</summary>

/// <returns>The created lazy list.</returns>

/// <typeparam name="T">The expected element type.</typeparam>

/// <param name="value">The reflectable container.</param>

template

typename

collections

LazyList

GetLazyList

(

Ptr

IValueList

value

) {

return

GetLazyList

Ptr

IValueReadonlyList

value

)); }

/// <summary>Convert a reflectable container to a lazy list to the known element type.</summary>

/// <returns>The created lazy list.</returns>

/// <typeparam name="T">The expected element type.</typeparam>

/// <param name="value">The reflectable container.</param>

template

typename

collections

LazyList

GetLazyList

(

Ptr

IValueObservableList

value

) {

return

GetLazyList

Ptr

IValueReadonlyList

value

)); }

/// <summary>Convert a reflectable dictionary to a lazy list to the known element type.</summary>

/// <returns>The created lazy list.</returns>

/// <typeparam name="K">The expected key type.</typeparam>

/// <typeparam name="V">The expected value type.</typeparam>

/// <param name="value">The reflectable dictionary.</param>

template

typename

collections

LazyList

collections

Pair

GetLazyList

(

Ptr

IValueReadonlyDictionary

value

) {

return

collections

Range

vint

value

GetCount

()) .

Select

([value](

vint

) {

return

collections

Pair

UnboxValue

value

GetKeys

()

Get

(

)),

UnboxValue

value

GetValues

()

Get

(

))); }); }

/// <summary>Convert a reflectable dictionary to a lazy list to the known element type.</summary>

/// <returns>The created lazy list.</returns>

/// <typeparam name="K">The expected key type.</typeparam>

/// <typeparam name="V">The expected value type.</typeparam>

/// <param name="value">The reflectable dictionary.</param>

template

typename

collections

LazyList

collections

Pair

GetLazyList

(

Ptr

IValueDictionary

value

) {

return

GetLazyList

Ptr

IValueReadonlyDictionary

value

)); }

/*********************************************************************** Collection Wrappers ***********************************************************************/

namespace

trait_helper

{

template

typename

struct

RemovePtr

{

typedef

Type

; };

template

typename

struct

RemovePtr

*> {

typedef

Type

; };

template

typename

struct

RemovePtr

Ptr

>> {

typedef

Type

; }; } #pragma warning(push) #pragma warning(disable:

4250

)

template

typename

class

ValueEnumeratorWrapper

public

Object

public

virtual

IValueEnumerator

{

protected

typedef

typename

trait_helper

RemovePtr

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

wrapperPointer

;

public

ValueEnumeratorWrapper

(

const

_wrapperPointer

) :wrapperPointer(

_wrapperPointer

) { }

Value

GetCurrent

()

override

{

return

BoxValue

ElementType

wrapperPointer

->Current()); }

vint

GetIndex

()

override

{

return

wrapperPointer

->Index(); }

bool

()

override

{

return

wrapperPointer

->Next(); } };

template

typename

class

ValueEnumerableWrapper

public

Object

public

virtual

IValueEnumerable

{

protected

typedef

typename

trait_helper

RemovePtr

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

wrapperPointer

;

public

ValueEnumerableWrapper

(

const

_wrapperPointer

) :wrapperPointer(

_wrapperPointer

) { }

Ptr

IValueEnumerator

CreateEnumerator

()

override

{

return

new

ValueEnumeratorWrapper

Ptr

collections

IEnumerator

ElementType

>>>(

wrapperPointer

->CreateEnumerator()); } };

#define WRAPPER_POINTER this->wrapperPointer

template

typename

class

ValueReadonlyListWrapper

public

ValueEnumerableWrapper

public

virtual

IValueReadonlyList

{

protected

typedef

typename

trait_helper

RemovePtr

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

typedef

typename

KeyType

ElementType

>::

Type

ElementKeyType

;

public

ValueReadonlyListWrapper

(

const

_wrapperPointer

) :

ValueEnumerableWrapper

_wrapperPointer

) { }

vint

GetCount

()

override

{

return WRAPPER_POINTER->Count();

return

this

wrapperPointer

->Count();

}

Value

Get

(

vint

index

)

override

{

return BoxValue<ElementType>(WRAPPER_POINTER->Get(index));

return

BoxValue

ElementType

this

wrapperPointer

->Get(

index

));

}

bool

Contains

(

const

Value

value

)

override

{

ElementKeyType

item

UnboxValue

ElementKeyType

value

);

return WRAPPER_POINTER->Contains(item);

return

this

wrapperPointer

->Contains(

item

);

}

vint

IndexOf

(

const

Value

value

)

override

{

ElementKeyType

item

UnboxValue

ElementKeyType

value

);

return WRAPPER_POINTER->IndexOf(item);

return

this

wrapperPointer

->IndexOf(

item

);

} };

template

typename

class

ValueListWrapper

public

ValueReadonlyListWrapper

public

virtual

IValueList

{

protected

typedef

typename

trait_helper

RemovePtr

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

typedef

typename

KeyType

ElementType

>::

Type

ElementKeyType

;

public

ValueListWrapper

(

const

_wrapperPointer

) :

ValueReadonlyListWrapper

_wrapperPointer

) { }

void

Set

(

vint

index

const

Value

value

)

override

{

ElementType

item

UnboxValue

ElementType

value

);

WRAPPER_POINTER->Set(index, item);

this

wrapperPointer

->Set(

index

item

);

}

vint

Add

(

const

Value

value

)

override

{

ElementType

item

UnboxValue

ElementType

value

);

return WRAPPER_POINTER->Add(item);

return

this

wrapperPointer

->Add(

item

);

}

vint

Insert

(

vint

index

const

Value

value

)

override

{

ElementType

item

UnboxValue

ElementType

value

);

return WRAPPER_POINTER->Insert(index, item);

return

this

wrapperPointer

->Insert(

index

item

);

}

bool

Remove

(

const

Value

value

)

override

{

ElementKeyType

item

UnboxValue

ElementKeyType

value

);

return WRAPPER_POINTER->Remove(item);

return

this

wrapperPointer

->Remove(

item

);

}

bool

RemoveAt

(

vint

index

)

override

{

return WRAPPER_POINTER->RemoveAt(index);

return

this

wrapperPointer

->RemoveAt(

index

);

}

void

Clear

()

override

{

WRAPPER_POINTER->Clear();

this

wrapperPointer

->Clear();

} };

template

typename

class

ValueListWrapper

collections

Array

>*> :

public

ValueReadonlyListWrapper

collections

Array

>*>,

public

virtual

IValueList

{

protected

typedef

collections

Array

ContainerType

;

typedef

ElementType

;

typedef

ElementKeyType

;

public

ValueListWrapper

(

collections

Array

_wrapperPointer

) :

ValueReadonlyListWrapper

collections

Array

>*>(

_wrapperPointer

) { }

void

Set

(

vint

index

const

Value

value

)

override

{

ElementType

item

UnboxValue

ElementType

value

);

WRAPPER_POINTER->Set(index, item);

this

wrapperPointer

Set

(

index

item

);

}

vint

Add

(

const

Value

value

)

override

{

throw

Exception

(

L"Array doesn't have Add method."

); }

vint

Insert

(

vint

index

const

Value

value

)

override

{

throw

Exception

(

L"Array doesn't have Insert method."

); }

bool

Remove

(

const

Value

value

)

override

{

throw

Exception

(

L"Array doesn't have Remove method."

); }

bool

RemoveAt

(

vint

index

)

override

{

throw

Exception

(

L"Array doesn't have RemoveAt method."

); }

void

Clear

()

override

{

throw

Exception

(

L"Array doesn't have Clear method."

); } };

template

typename

class

ValueListWrapper

collections

SortedList

>*> :

public

ValueReadonlyListWrapper

collections

SortedList

>*>,

public

virtual

IValueList

{

protected

typedef

collections

SortedList

ContainerType

;

typedef

ElementType

;

typedef

ElementKeyType

;

public

ValueListWrapper

(

collections

SortedList

_wrapperPointer

) :

ValueReadonlyListWrapper

collections

SortedList

>*>(

_wrapperPointer

) { }

void

Set

(

vint

index

const

Value

value

)

override

{

throw

Exception

(

L"SortedList doesn't have Set method."

); }

vint

Add

(

const

Value

value

)

override

{

ElementType

item

UnboxValue

ElementType

value

);

return WRAPPER_POINTER->Add(item);

return

this

wrapperPointer

Add

(

item

);

}

vint

Insert

(

vint

index

const

Value

value

)

override

{

throw

Exception

(

L"SortedList doesn't have Insert method."

); }

bool

Remove

(

const

Value

value

)

override

{

ElementKeyType

item

UnboxValue

ElementKeyType

value

);

return WRAPPER_POINTER->Remove(item);

return

this

wrapperPointer

Remove

(

item

);

}

bool

RemoveAt

(

vint

index

)

override

{

return WRAPPER_POINTER->RemoveAt(index);

return

this

wrapperPointer

RemoveAt

(

index

);

}

void

Clear

()

override

{

WRAPPER_POINTER->Clear();

this

wrapperPointer

Clear

();

} };

template

typename

class

ValueObservableListWrapper

public

ValueListWrapper

public

virtual

IValueObservableList

{

public

ValueObservableListWrapper

(

const

_wrapperPointer

) :

ValueListWrapper

_wrapperPointer

) { } };

#undef WRAPPER_POINTER

template

typename

class

ValueReadonlyDictionaryWrapper

public

virtual

Object

public

virtual

IValueReadonlyDictionary

{

protected

typedef

typename

trait_helper

RemovePtr

>::

Type

ContainerType

;

typedef

typename

ContainerType

::KeyContainer

KeyContainer

;

typedef

typename

ContainerType

::ValueContainer

ValueContainer

;

typedef

typename

KeyContainer

::ElementType

KeyValueType

;

typedef

typename

KeyType

KeyValueType

>::

Type

KeyKeyType

;

typedef

typename

ValueContainer

::ElementType

ValueType

;

wrapperPointer

;

Ptr

IValueReadonlyList

keys

;

Ptr

IValueReadonlyList

values

;

public

ValueReadonlyDictionaryWrapper

(

const

_wrapperPointer

) :wrapperPointer(

_wrapperPointer

) { }

Ptr

IValueReadonlyList

GetKeys

()

override

{

keys

) {

keys

new

ValueReadonlyListWrapper

const

KeyContainer

*>(&

wrapperPointer

->Keys()); }

return

keys

; }

Ptr

IValueReadonlyList

GetValues

()

override

{

values

) {

values

new

ValueReadonlyListWrapper

const

ValueContainer

*>(&

wrapperPointer

->Values()); }

return

values

; }

vint

GetCount

()

override

{

return

wrapperPointer

->Count(); }

Value

Get

(

const

Value

key

)

override

{

KeyKeyType

item

UnboxValue

KeyKeyType

key

);

ValueType

result

wrapperPointer

->Get(

item

);

return

BoxValue

ValueType

result

); } };

#define WRAPPER_POINTER ValueReadonlyDictionaryWrapper<T>::wrapperPointer

#define KEY_VALUE_TYPE typename ValueReadonlyDictionaryWrapper<T>::KeyValueType

#define VALUE_TYPE typename ValueReadonlyDictionaryWrapper<T>::ValueType

#define KEY_KEY_TYPE typename ValueReadonlyDictionaryWrapper<T>::KeyKeyType

template

typename

class

ValueDictionaryWrapper

public

virtual

ValueReadonlyDictionaryWrapper

public

virtual

IValueDictionary

{

public

ValueDictionaryWrapper

(

const

_wrapperPointer

) :

ValueReadonlyDictionaryWrapper

_wrapperPointer

) { }

void

Set

(

const

Value

key

const

Value

value

)

override

{

KEY_VALUE_TYPE item=UnboxValue<KEY_VALUE_TYPE>(key);

typename

ValueReadonlyDictionaryWrapper

>::

KeyValueType

item

UnboxValue

typename

ValueReadonlyDictionaryWrapper

>::

KeyValueType

key

);

VALUE_TYPE result=UnboxValue<VALUE_TYPE>(value);

typename

ValueReadonlyDictionaryWrapper

>::

ValueType

result

UnboxValue

typename

ValueReadonlyDictionaryWrapper

>::

ValueType

value

);

WRAPPER_POINTER->Set(item, result);

ValueReadonlyDictionaryWrapper

>::

wrapperPointer

->Set(

item

result

);

}

bool

Remove

(

const

Value

key

)

override

{

KEY_KEY_TYPE item=UnboxValue<KEY_KEY_TYPE>(key);

typename

ValueReadonlyDictionaryWrapper

>::

KeyKeyType

item

UnboxValue

typename

ValueReadonlyDictionaryWrapper

>::

KeyKeyType

key

);

return WRAPPER_POINTER->Remove(item);

return

ValueReadonlyDictionaryWrapper

>::

wrapperPointer

->Remove(

item

);

}

void

Clear

()

override

{

WRAPPER_POINTER->Clear();

ValueReadonlyDictionaryWrapper

>::

wrapperPointer

->Clear();

} };

#undef WRAPPER_POINTER

#undef KEY_VALUE_TYPE

#undef VALUE_TYPE

#undef KEY_KEY_TYPE

#pragma warning(pop)

/*********************************************************************** DetailTypeInfoRetriver<TContainer> ***********************************************************************/

template

typename

struct

DetailTypeInfoRetriver

TypeFlags

EnumerableType

> {

typedef

DetailTypeInfoRetriver

TypeFlags

NonGenericType

UpLevelRetriver

;

static

const

ITypeInfo

Decorator

UpLevelRetriver

Decorator

;

typedef

IValueEnumerable

Type

;

typedef

typename

UpLevelRetriver

TempValueType

;

typedef

typename

UpLevelRetriver

ResultReferenceType

;

typedef

typename

UpLevelRetriver

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

(

TypeInfoHint

hint

) {

typedef

typename

DetailTypeInfoRetriver

TypeFlags

NonGenericType

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

auto

arrayType

MakePtr

TypeDescriptorTypeInfo

GetTypeDescriptor

IValueEnumerable

>(),

hint

);

auto

genericType

MakePtr

GenericTypeInfo

arrayType

);

genericType

AddGenericArgument

(

TypeInfoRetriver

ElementType

>::

CreateTypeInfo

());

auto

type

MakePtr

SharedPtrTypeInfo

genericType

);

return

type

; }

#endif

};

template

typename

struct

DetailTypeInfoRetriver

TypeFlags

ReadonlyListType

> {

typedef

DetailTypeInfoRetriver

TypeFlags

NonGenericType

UpLevelRetriver

;

static

const

ITypeInfo

Decorator

UpLevelRetriver

Decorator

;

typedef

IValueReadonlyList

Type

;

typedef

typename

UpLevelRetriver

TempValueType

;

typedef

typename

UpLevelRetriver

ResultReferenceType

;

typedef

typename

UpLevelRetriver

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

(

TypeInfoHint

hint

) {

typedef

typename

DetailTypeInfoRetriver

TypeFlags

NonGenericType

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

auto

arrayType

MakePtr

TypeDescriptorTypeInfo

GetTypeDescriptor

IValueReadonlyList

>(),

hint

);

auto

genericType

MakePtr

GenericTypeInfo

arrayType

);

genericType

AddGenericArgument

(

TypeInfoRetriver

ElementType

>::

CreateTypeInfo

());

auto

type

MakePtr

SharedPtrTypeInfo

genericType

);

return

type

; }

#endif

};

template

typename

struct

DetailTypeInfoRetriver

TypeFlags

ListType

> {

typedef

DetailTypeInfoRetriver

TypeFlags

NonGenericType

UpLevelRetriver

;

static

const

ITypeInfo

Decorator

UpLevelRetriver

Decorator

;

typedef

IValueList

Type

;

typedef

typename

UpLevelRetriver

TempValueType

;

typedef

typename

UpLevelRetriver

ResultReferenceType

;

typedef

typename

UpLevelRetriver

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

(

TypeInfoHint

hint

) {

typedef

typename

DetailTypeInfoRetriver

TypeFlags

NonGenericType

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

auto

arrayType

MakePtr

TypeDescriptorTypeInfo

GetTypeDescriptor

IValueList

>(),

hint

);

auto

genericType

MakePtr

GenericTypeInfo

arrayType

);

genericType

AddGenericArgument

(

TypeInfoRetriver

ElementType

>::

CreateTypeInfo

());

auto

type

MakePtr

SharedPtrTypeInfo

genericType

);

return

type

; }

#endif

};

template

typename

struct

DetailTypeInfoRetriver

TypeFlags

ObservableListType

> {

typedef

DetailTypeInfoRetriver

TypeFlags

NonGenericType

UpLevelRetriver

;

static

const

ITypeInfo

Decorator

UpLevelRetriver

Decorator

;

typedef

IValueObservableList

Type

;

typedef

typename

UpLevelRetriver

TempValueType

;

typedef

typename

UpLevelRetriver

ResultReferenceType

;

typedef

typename

UpLevelRetriver

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

(

TypeInfoHint

hint

) {

typedef

typename

DetailTypeInfoRetriver

TypeFlags

NonGenericType

>::

Type

ContainerType

;

typedef

typename

ContainerType

::ElementType

ElementType

;

auto

arrayType

MakePtr

TypeDescriptorTypeInfo

GetTypeDescriptor

IValueObservableList

>(),

hint

);

auto

genericType

MakePtr

GenericTypeInfo

arrayType

);

genericType

AddGenericArgument

(

TypeInfoRetriver

ElementType

>::

CreateTypeInfo

());

auto

type

MakePtr

SharedPtrTypeInfo

genericType

);

return

type

; }

#endif

};

template

typename

struct

DetailTypeInfoRetriver

TypeFlags

ReadonlyDictionaryType

> {

typedef

DetailTypeInfoRetriver

TypeFlags

NonGenericType

UpLevelRetriver

;

static

const

ITypeInfo

Decorator

UpLevelRetriver

Decorator

;

typedef

IValueReadonlyList

Type

;

typedef

typename

UpLevelRetriver

TempValueType

;

typedef

typename

UpLevelRetriver

ResultReferenceType

;

typedef

typename

UpLevelRetriver

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

(

TypeInfoHint

hint

) {

typedef

typename

DetailTypeInfoRetriver

TypeFlags

NonGenericType

>::

Type

ContainerType

;

typedef

typename

ContainerType

::KeyContainer

KeyContainer

;

typedef

typename

ContainerType

::ValueContainer

ValueContainer

;

typedef

typename

KeyContainer

::ElementType

KeyType

;

typedef

typename

ValueContainer

::ElementType

ValueType

;

auto

arrayType

MakePtr

TypeDescriptorTypeInfo

GetTypeDescriptor

IValueReadonlyDictionary

>(),

hint

);

auto

genericType

MakePtr

GenericTypeInfo

arrayType

);

genericType

AddGenericArgument

(

TypeInfoRetriver

KeyType

>::

CreateTypeInfo

());

genericType

AddGenericArgument

(

TypeInfoRetriver

ValueType

>::

CreateTypeInfo

());

auto

type

MakePtr

SharedPtrTypeInfo

genericType

);

return

type

; }

#endif

};

template

typename

struct

DetailTypeInfoRetriver

TypeFlags

DictionaryType

> {

typedef

DetailTypeInfoRetriver

TypeFlags

NonGenericType

UpLevelRetriver

;

static

const

ITypeInfo

Decorator

UpLevelRetriver

Decorator

;

typedef

IValueReadonlyList

Type

;

typedef

typename

UpLevelRetriver

TempValueType

;

typedef

typename

UpLevelRetriver

ResultReferenceType

;

typedef

typename

UpLevelRetriver

ResultNonReferenceType

;

#ifndef VCZH_DEBUG_NO_REFLECTION

static

Ptr

ITypeInfo

CreateTypeInfo

(

TypeInfoHint

hint

) {

typedef

typename

DetailTypeInfoRetriver

TypeFlags

NonGenericType

>::

Type

ContainerType

;

typedef

typename

ContainerType

::KeyContainer

KeyContainer

;

typedef

typename

ContainerType

::ValueContainer

ValueContainer

;

typedef

typename

KeyContainer

::ElementType

KeyType

;

typedef

typename

ValueContainer

::ElementType

ValueType

;

auto

arrayType

MakePtr

TypeDescriptorTypeInfo

GetTypeDescriptor

IValueDictionary

>(),

hint

);

auto

genericType

MakePtr

GenericTypeInfo

arrayType

);

genericType

AddGenericArgument

(

TypeInfoRetriver

KeyType

>::

CreateTypeInfo

());

genericType

AddGenericArgument

(

TypeInfoRetriver

ValueType

>::

CreateTypeInfo

());

auto

type

MakePtr

SharedPtrTypeInfo

genericType

);

return

type

; }

#endif

};

/*********************************************************************** ParameterAccessor<TContainer> ***********************************************************************/

template

typename

struct

ParameterAccessor

collections

LazyList

TypeFlags

EnumerableType

> {

static

Value

BoxParameter

(

collections

LazyList

object

ITypeDescriptor

typeDescriptor

) {

Ptr

IValueEnumerable

result

IValueEnumerable

Create

(

collections

From

(

object

) .Select([](

const

item

) {

return

BoxValue

item

); }) );

ITypeDescriptor

nullptr

;

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

Description

IValueEnumerable

>::

GetAssociatedTypeDescriptor

();

#endif

return

BoxValue

Ptr

IValueEnumerable

>>(

result

); }

static

void

UnboxParameter

(

const

Value

value

collections

LazyList

result

ITypeDescriptor

typeDescriptor

const

WString

valueName

) {

typedef

typename

collections

LazyList

>::

ElementType

;

Ptr

IValueEnumerable

listProxy

UnboxValue

Ptr

IValueEnumerable

>>(

value

typeDescriptor

valueName

);

result

GetLazyList

listProxy

); } };

template

typename

struct

ParameterAccessor

TypeFlags

ReadonlyListType

> {

static

Value

BoxParameter

(

object

ITypeDescriptor

typeDescriptor

) {

Ptr

IValueReadonlyList

result

new

ValueReadonlyListWrapper

*>(&

object

);

ITypeDescriptor

nullptr

;

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

Description

IValueReadonlyList

>::

GetAssociatedTypeDescriptor

();

#endif

return

BoxValue

Ptr

IValueReadonlyList

>>(

result

); }

static

void

UnboxParameter

(

const

Value

value

result

ITypeDescriptor

typeDescriptor

const

WString

valueName

) {

typedef

typename

::ElementType

ElementType

;

Ptr

IValueReadonlyList

listProxy

UnboxValue

Ptr

IValueReadonlyList

>>(

value

typeDescriptor

valueName

);

collections

LazyList

ElementType

lazyList

GetLazyList

ElementType

listProxy

);

collections

CopyFrom

(

result

lazyList

); } };

template

typename

struct

ParameterAccessor

TypeFlags

ListType

> {

static

Value

BoxParameter

(

object

ITypeDescriptor

typeDescriptor

) {

Ptr

IValueList

result

new

ValueListWrapper

*>(&

object

);

ITypeDescriptor

nullptr

;

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

Description

IValueList

>::

GetAssociatedTypeDescriptor

();

#endif

return

BoxValue

Ptr

IValueList

>>(

result

); }

static

void

UnboxParameter

(

const

Value

value

result

ITypeDescriptor

typeDescriptor

const

WString

valueName

) {

typedef

typename

::ElementType

ElementType

;

Ptr

IValueList

listProxy

UnboxValue

Ptr

IValueList

>>(

value

typeDescriptor

valueName

);

collections

LazyList

ElementType

lazyList

GetLazyList

ElementType

listProxy

);

collections

CopyFrom

(

result

lazyList

); } };

template

typename

struct

ParameterAccessor

collections

ObservableList

TypeFlags

ObservableListType

> {

static

Value

BoxParameter

(

collections

ObservableList

object

ITypeDescriptor

typeDescriptor

) {

ITypeDescriptor

nullptr

;

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

Description

IValueObservableList

>::

GetAssociatedTypeDescriptor

();

#endif

return

BoxValue

Ptr

IValueObservableList

>>(

object

GetWrapper

(),

); } };

template

typename

struct

ParameterAccessor

TypeFlags

ReadonlyDictionaryType

> {

static

Value

BoxParameter

(

object

ITypeDescriptor

typeDescriptor

) {

Ptr

IValueReadonlyDictionary

result

new

ValueReadonlyDictionaryWrapper

*>(&

object

);

ITypeDescriptor

nullptr

;

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

Description

IValueReadonlyDictionary

>::

GetAssociatedTypeDescriptor

();

#endif

return

BoxValue

Ptr

IValueReadonlyDictionary

>>(

result

); }

static

void

UnboxParameter

(

const

Value

value

result

ITypeDescriptor

typeDescriptor

const

WString

valueName

) {

typedef

typename

::KeyContainer

KeyContainer

;

typedef

typename

::ValueContainer

ValueContainer

;

typedef

typename

KeyContainer

::ElementType

KeyType

;

typedef

typename

ValueContainer

::ElementType

ValueType

;

Ptr

IValueReadonlyDictionary

dictionaryProxy

UnboxValue

Ptr

IValueReadonlyDictionary

>>(

value

typeDescriptor

valueName

);

collections

LazyList

collections

Pair

KeyType

ValueType

lazyList

GetLazyList

KeyType

ValueType

dictionaryProxy

);

collections

CopyFrom

(

result

lazyList

); } };

template

typename

struct

ParameterAccessor

TypeFlags

DictionaryType

> {

static

Value

BoxParameter

(

object

ITypeDescriptor

typeDescriptor

) {

Ptr

IValueDictionary

result

new

ValueDictionaryWrapper

*>(&

object

);

ITypeDescriptor

nullptr

;

#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA

Description

IValueDictionary

>::

GetAssociatedTypeDescriptor

();

#endif

return

BoxValue

Ptr

IValueDictionary

>>(

result

); }

static

void

UnboxParameter

(

const

Value

value

result

ITypeDescriptor

typeDescriptor

const

WString

valueName

) {

typedef

typename

::KeyContainer

KeyContainer

;

typedef

typename

::ValueContainer

ValueContainer

;

typedef

typename

KeyContainer

::ElementType

KeyType

;

typedef

typename

ValueContainer

::ElementType

ValueType

;

Ptr

IValueDictionary

dictionaryProxy

UnboxValue

Ptr

IValueDictionary

>>(

value

typeDescriptor

valueName

);

collections

LazyList

collections

Pair

KeyType

ValueType

lazyList

GetLazyList

KeyType

ValueType

dictionaryProxy

);

collections

CopyFrom

(

result

lazyList

); } }; } }

namespace

collections

{

/// <summary>Base type of observable container which triggers callbacks whenever items are changed.</summary>

/// <typeparam name="T">Type of elements.</typeparam>

/// <typeparam name="K">Type of the key type of elements. It is recommended to use the default value.</typeparam>

/// <remarks>

/// Methods are the same to <see cref="List`2"/>, except that operator[] is readonly.

///

/// When an item is being inserted to the list,

/// QueryInsert will be called to determine if this item can be inserted,

/// BeforeInsert will be called before inserting,

/// AfterInsert will be called after inserting.

///

///

/// When an item is being removed from the list,

/// QueryRemove will be called to determine if this item can be removed,

/// BeforeRemove will be called before removing,

/// AfterRemove will be called after removing.

///

///

/// When an item is being replaced, it is considered as removing the original item and inserting the new item.

///

///

/// After any changing happens, NotifyUpdateInternal is called.

/// Arguments is exactly the same as <see cref="reflection::description::IValueObservableList::ItemChanged"/>.

///

/// </remarks>

template

typename

KeyType

>::

Type

class

ObservableListBase

public

Object

public

virtual

collections

IEnumerable

> {

protected

collections

List

items

;

virtual

void

NotifyUpdateInternal

(

vint

start

vint

count

vint

newCount

) { }

virtual

bool

QueryInsert

(

vint

index

const

value

) {

return

true

; }

virtual

void

BeforeInsert

(

vint

index

const

value

) { }

virtual

void

AfterInsert

(

vint

index

const

value

) { }

virtual

bool

QueryRemove

(

vint

index

const

value

) {

return

true

; }

virtual

void

BeforeRemove

(

vint

index

const

value

) { }

virtual

void

AfterRemove

(

vint

index

vint

count

) { }

public

ObservableListBase

() { }

ObservableListBase

() { }

collections

IEnumerator

CreateEnumerator

()

const

{

return

items

CreateEnumerator

(); }

/// <summary>Trigger NotifyUpdateInternal manually.</summary>

/// <returns>Returns true if arguments are not out of range.</returns>

/// <param name="start">The index of the first item that are changed.</param>

/// <param name="count">The number of items that are changed, the default value is 1.</param>

/// <remarks>

///

/// This is useful when the container is not actually changed, but data in some items are changed.

/// For example, in an observable list of shared pointers,

/// properties of elements are changed does not trigger callbacks because it doesn't change pointers in the list.

///

///

/// If subscribers need to know about such change, calling this function is an easy way to do it.

///

/// </remarks>

bool

NotifyUpdate

(

vint

start

vint

count

) {

(

start

items

Count

() ||

count

start

count

items

Count

()) {

return

false

; }

else

{

NotifyUpdateInternal

(

start

count

);

return

true

; } }

bool

Contains

(

const

item

)

const

{

return

items

Contains

(

item

); }

vint

Count

()

const

{

return

items

Count

(); }

vint

Count

() {

return

items

Count

(); }

const

Get

(

vint

index

)

const

{

return

items

Get

(

index

); }

const

operator

[

]

(

vint

index

)

const

{

return

items

Get

(

index

); }

vint

IndexOf

(

const

item

)

const

{

return

items

IndexOf

(

item

); }

vint

Add

(

const

item

) {

return

Insert

(

items

Count

(),

item

); }

bool

Remove

(

const

item

) {

vint

index

items

IndexOf

(

item

);

(

index

== -

)

return

false

;

return

RemoveAt

(

index

); }

bool

RemoveAt

(

vint

index

) {

(

index

items

Count

() &&

QueryRemove

(

index

items

[

index

])) {

BeforeRemove

(

index

items

[

index

]);

item

items

[

index

];

items

RemoveAt

(

index

);

AfterRemove

(

index

);

NotifyUpdateInternal

(

index

);

return

true

; }

return

false

; }

bool

RemoveRange

(

vint

index

vint

count

) {

(

count

)

return

false

;

(

index

items

Count

() &&

index

count

items

Count

()) {

for

(

vint

;

count

;

++) {

QueryRemove

(

index

items

[

index

]))

return

false

; }

for

(

vint

;

count

;

++) {

BeforeRemove

(

index

items

[

index

]); }

items

RemoveRange

(

index

count

);

AfterRemove

(

index

count

);

NotifyUpdateInternal

(

index

count

);

return

true

; }

return

false

; }

bool

Clear

() {

vint

count

items

Count

();

for

(

vint

;

count

;

++) {

QueryRemove

(

items

[

]))

return

false

; }

for

(

vint

;

count

;

++) {

BeforeRemove

(

items

[

]); }

items

Clear

();

AfterRemove

(

count

);

NotifyUpdateInternal

(

count

);

return

true

; }

vint

Insert

(

vint

index

const

item

) {

(

index

items

Count

() &&

QueryInsert

(

index

item

)) {

BeforeInsert

(

index

item

);

items

Insert

(

index

item

);

AfterInsert

(

index

item

);

NotifyUpdateInternal

(

index

);

return

index

; }

else

{

return

; } }

bool

Set

(

vint

index

const

item

) {

(

index

items

Count

()) {

(

QueryRemove

(

index

items

[

index

]) &&

QueryInsert

(

index

item

)) {

BeforeRemove

(

index

items

[

index

]);

items

RemoveAt

(

index

);

AfterRemove

(

index

);

BeforeInsert

(

index

item

);

items

Insert

(

index

item

);

AfterInsert

(

index

item

);

NotifyUpdateInternal

(

index

);

return

true

; } }

return

false

; } };

/// <summary>An observable container that maintain an implementation of <see cref="reflection::description::IValueObservableList"/>.</summary>

/// <typeparam name="T">Type of elements.</typeparam>

/// <typeparam name="K">Type of the key type of elements. It is recommended to use the default value.</typeparam>

template

typename

class

ObservableList

public

ObservableListBase

> {

protected

Ptr

reflection

description

IValueObservableList

observableList

;

void

NotifyUpdateInternal

(

vint

start

vint

count

vint

newCount

)

override

{

(

observableList

) {

observableList

ItemChanged

(

start

count

newCount

); } }

public

/// <summary>

/// Get the maintained observable list.

/// <see cref="reflection::description::IValueObservableList::ItemChanged"/> of the observable list

/// will be automatically triggered when any changing happens.

/// </summary>

/// <returns>The maintained observable list.</returns>

/// <remarks>

///

/// <see cref="reflection::description::BoxParameter`1"/>

/// cannot turn any predefined C++ object to an reflectable observable list

/// and keep it binding to the C++ object.

/// When an reflectable observable list is required, ObservableList is strongly recommended.

///

/// </remarks>

Ptr

reflection

description

IValueObservableList

GetWrapper

() {

observableList

) {

observableList

new

reflection

description

ValueObservableListWrapper

ObservableList

>*>(

this

); }

return

observableList

; } };

namespace

randomaccess_internal

{

template

typename

struct

RandomAccessable

ObservableListBase

>> {

static

const

bool

CanRead

true

;

static

const

bool

CanResize

false

; };

template

typename

struct

RandomAccessable

ObservableList

>> {

static

const

bool

CanRead

true

;

static

const

bool

CanResize

false

; }; } } }

#endif