List.h

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

#ifndef VCZH_COLLECTIONS_LIST

#define VCZH_COLLECTIONS_LIST

#include <string.h>

#include "Interfaces.h"

#ifdef VCZH_CHECK_MEMORY_LEAKS_NEW

#undef new

#endif

#include <new>

namespace

{

namespace

collections

{

/*********************************************************************** Memory Management ***********************************************************************/

template

typename

bool

PODType

class

ListStore

abstract

public

Object

{ };

template

typename

class

ListStore

false

abstract

public

Object

{

protected

static

void

InitializeItemsByDefault

(

void

dst

vint

count

) {

= (

dst

;

for

(

vint

;

count

;

++) {

new

[

])

(); } }

static

void

InitializeItemsByMove

(

void

dst

void

src

vint

count

) {

= (

dst

;

= (

src

;

for

(

vint

;

count

;

++) {

new

[

])

(

MoveValue

(

[

])); } }

static

void

InitializeItemsByCopy

(

void

dst

void

src

vint

count

) {

= (

dst

;

= (

src

;

for

(

vint

;

count

;

++) {

new

[

])

(

[

]); } }

static

void

MoveItemsInTheSameBuffer

(

void

dst

void

src

vint

count

) {

= (

dst

;

= (

src

;

(

) {

for

(

vint

;

count

;

++) {

[

] =

MoveValue

(

[

]); } }

else

(

) {

for

(

vint

count

;

--) {

[

] =

MoveValue

(

[

]); } } }

static

void

ReleaseItems

(

void

dst

vint

count

) {

= (

dst

;

for

(

vint

;

count

;

++) {

[

].~T(); } }

static

void

AllocateBuffer

(

vint

size

) {

(

size

)

return

nullptr

;

return

(

void

malloc

(

sizeof

(

) *

size

); }

static

void

DeallocateBuffer

(

void

buffer

) {

(

buffer

nullptr

)

return

;

free

(

buffer

); }

public

: };

template

typename

class

ListStore

true

abstract

public

Object

{

protected

static

void

InitializeItemsByDefault

(

void

dst

vint

count

) { }

static

void

InitializeItemsByMove

(

void

dst

void

src

vint

count

) {

(

count

) {

memcpy

(

dst

src

sizeof

(

) *

count

); } }

static

void

InitializeItemsByCopy

(

void

dst

void

src

vint

count

) {

(

count

) {

memcpy

(

dst

src

sizeof

(

) *

count

); } }

static

void

MoveItemsInTheSameBuffer

(

void

dst

void

src

vint

count

) {

(

count

) {

memmove

(

dst

src

sizeof

(

) *

count

); } }

static

void

ReleaseItems

(

void

dst

vint

count

) { }

static

void

AllocateBuffer

(

vint

size

) {

(

size

)

return

nullptr

;

return

(

void

malloc

(

sizeof

(

) *

size

); }

static

void

DeallocateBuffer

(

void

buffer

) {

(

buffer

nullptr

)

return

;

free

(

buffer

); }

public

: };

/*********************************************************************** ArrayBase ***********************************************************************/

/// <summary>Base type of all linear container.</summary>

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

template

typename

class

ArrayBase

abstract

public

ListStore

POD

>::

Result

public

virtual

IEnumerable

> {

protected

class

Enumerator

public

Object

public

virtual

IEnumerator

> {

private

const

ArrayBase

container

;

vint

index

;

public

Enumerator

(

const

ArrayBase

_container

vint

_index

= -

) {

container

_container

;

index

_index

; }

IEnumerator

Clone

()

const

override

{

return

new

Enumerator

(

container

index

); }

const

Current

()

const

override

{

return

container

Get

(

index

); }

vint

Index

()

const

override

{

return

index

; }

bool

()

override

{

index

++;

return

index

container

Count

(); }

void

Reset

()

override

{

index

= -

; }

bool

Evaluated

()

const

override

{

return

true

; } };

void

buffer

nullptr

;

vint

count

;

static

void

AddressOf

(

void

bufferOfTs

vint

index

) {

return

(

void

*)((

char

bufferOfTs

sizeof

(

) *

index

); }

const

ItemOf

(

vint

index

)

const

{

return

const

AddressOf

(

buffer

index

); }

ItemOf

(

vint

index

) {

return

AddressOf

(

buffer

index

); }

public

ArrayBase

() { }

IEnumerator

CreateEnumerator

()

const

{

return

new

Enumerator

(

this

); }

/// <summary>Get the number of elements in the container.</summary>

/// <returns>The number of elements.</returns>

vint

Count

()

const

{

return

count

; }

/// <summary>Get the reference to the specified element.</summary>

/// <returns>The reference to the specified element. It will crash when the index is out of range.</returns>

/// <param name="index">The index of the element.</param>

const

Get

(

vint

index

)

const

{

CHECK_ERROR(index >= 0 && index < this->count, L"ArrayBase<T, K>::Get(vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"ArrayBase<T, K>::Get(vint)#Argument index not in range."

);}

while

(

);

return

ItemOf

(

index

); }

/// <summary>Get the reference to the specified element.</summary>

/// <returns>The reference to the specified element. It will crash when the index is out of range.</returns>

/// <param name="index">The index of the element.</param>

const

operator

[

]

(

vint

index

)

const

{

CHECK_ERROR(index >= 0 && index < this->count, L"ArrayBase<T, K>::operator[](vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"ArrayBase<T, K>::operator[](vint)#Argument index not in range."

);}

while

(

);

return

ItemOf

(

index

); } };

/*********************************************************************** Array ***********************************************************************/

/// <summary>Array: linear container with fixed size in runtime. All elements are contiguous in memory.</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

KeyType

>::

Type

class

Array

public

ArrayBase

> {

public

/// <summary>Create an array.</summary>

/// <param name="size">The size of the array.</param>

/// <remarks>

/// The default value is zero. <see cref="Resize"/> can be called to determine the size later.

/// It will crash when the size is a negative number.

/// </remarks>

Array

(

vint

size

) {

CHECK_ERROR(size >= 0, L"Array<T>::Array(vint)#Size should not be negative.");

{

(!(

size

))

throw

Error

(

L"Array<T>::Array(vint)#Size should not be negative."

);}

while

(

);

this

buffer

this

AllocateBuffer

(

size

);

this

InitializeItemsByDefault

(

this

buffer

size

);

this

count

size

; }

/// <summary>Create an array with elements provided.</summary>

/// <param name="_buffer">Pointer to values to copy.</param>

/// <param name="size">The number of values to copy.</param>

/// <remarks>It will crash when the size is a negative number.</remarks>

Array

(

const

_buffer

vint

size

) {

CHECK_ERROR(size >= 0, L"Array<T>::Array(const T*, vint)#Size should not be negative.");

{

(!(

size

))

throw

Error

(

L"Array<T>::Array(const T*, vint)#Size should not be negative."

);}

while

(

);

this

buffer

this

AllocateBuffer

(

size

);

this

InitializeItemsByCopy

(

this

buffer

, (

void

_buffer

size

);

this

count

size

; }

Array

() {

this

ReleaseItems

(

this

buffer

this

count

);

this

DeallocateBuffer

(

this

buffer

); }

/// <summary>Test does the array contain a value or not.</summary>

/// <returns>Returns true if the array contains the specified value.</returns>

/// <param name="item">The value to test.</param>

bool

Contains

(

const

item

)

const

{

return

IndexOf

(

item

) != -

; }

/// <summary>Get the position of a value in this array.</summary>

/// <returns>Returns the position of first element that equals to the specified value. Returns -1 if failed to find.</returns>

/// <param name="item">The value to find.</param>

vint

IndexOf

(

const

item

)

const

{

for

(

vint

;

this

count

;

++) {

(

this

ItemOf

(

) ==

item

) {

return

; } }

return

; }

/// <summary>Replace an element in the specified position.</summary>

/// <returns>Returns true if this operation succeeded. It will crash when the index is out of range</returns>

/// <param name="index">The position of the element to replace.</param>

/// <param name="item">The new value to replace.</param>

bool

Set

(

vint

index

const

item

) {

CHECK_ERROR(index >= 0 && index < this->count, L"Array<T, K>::Set(vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"Array<T, K>::Set(vint)#Argument index not in range."

);}

while

(

);

this

ItemOf

(

index

) =

item

;

return

true

; }

using

ArrayBase

>::

operator

[

]

;

/// <summary>Get the reference to the specified element.</summary>

/// <returns>The reference to the specified element. It will crash when the index is out of range.</returns>

/// <param name="index">The index of the element.</param>

operator

[

]

(

vint

index

) {

CHECK_ERROR(index >= 0 && index < this->count, L"Array<T, K>::operator[](vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"Array<T, K>::operator[](vint)#Argument index not in range."

);}

while

(

);

return

this

ItemOf

(

index

); }

/// <summary>Change the size of the array. This function can be called multiple times to change the size.</summary>

/// <param name="size">The new size of the array.</param>

/// <remarks>It will crash when the size is a negative number.</remarks>

void

Resize

(

vint

size

) {

CHECK_ERROR(size >= 0, L"Array<T>::Resize(vint)#Size should not be negative.");

{

(!(

size

))

throw

Error

(

L"Array<T>::Resize(vint)#Size should not be negative."

);}

while

(

);

void

newBuffer

this

AllocateBuffer

(

size

);

(

size

this

count

) {

this

InitializeItemsByMove

(

this

AddressOf

(

newBuffer

this

AddressOf

(

this

buffer

size

); }

else

{

this

InitializeItemsByMove

(

this

AddressOf

(

newBuffer

this

AddressOf

(

this

buffer

this

count

);

this

InitializeItemsByDefault

(

this

AddressOf

(

newBuffer

this

count

size

this

count

); }

this

ReleaseItems

(

this

buffer

this

count

);

this

DeallocateBuffer

(

this

buffer

);

this

buffer

newBuffer

;

this

count

size

; } };

/*********************************************************************** ListBase ***********************************************************************/

/// <summary>Base type for all list containers.</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

KeyType

>::

Type

class

ListBase

abstract

public

ArrayBase

> {

protected

vint

capacity

;

bool

lessMemoryMode

false

;

vint

CalculateCapacity

(

vint

expected

) {

vint

result

capacity

;

while

(

result

expected

) {

result

; }

return

result

; }

void

MakeRoom

(

vint

index

vint

_count

bool

uninitialized

) {

vint

newCount

this

count

_count

;

(

newCount

capacity

) {

vint

newCapacity

CalculateCapacity

(

newCount

);

void

newBuffer

this

AllocateBuffer

(

newCapacity

);

this

InitializeItemsByMove

(

this

AddressOf

(

newBuffer

this

AddressOf

(

this

buffer

index

);

this

InitializeItemsByMove

(

this

AddressOf

(

newBuffer

index

_count

this

AddressOf

(

this

buffer

index

this

count

index

);

this

ReleaseItems

(

this

buffer

this

count

);

this

DeallocateBuffer

(

this

buffer

);

this

capacity

newCapacity

;

this

buffer

newBuffer

;

uninitialized

true

; }

else

(

index

this

count

) {

uninitialized

true

; }

else

(

this

count

index

_count

) {

this

InitializeItemsByMove

(

this

AddressOf

(

this

buffer

index

_count

this

AddressOf

(

this

buffer

index

this

count

index

);

this

ReleaseItems

(

this

AddressOf

(

this

buffer

index

_count

- (

this

count

index

));

uninitialized

true

; }

else

{

this

InitializeItemsByMove

(

this

AddressOf

(

this

buffer

this

count

this

AddressOf

(

this

buffer

this

count

_count

);

this

MoveItemsInTheSameBuffer

(

this

AddressOf

(

this

buffer

index

_count

this

AddressOf

(

this

buffer

index

this

count

index

_count

);

uninitialized

false

; }

this

count

newCount

; }

void

ReleaseUnnecessaryBuffer

(

vint

previousCount

) {

(

this

buffer

this

count

previousCount

) {

this

ReleaseItems

(

this

AddressOf

(

this

buffer

this

count

previousCount

this

count

); }

(

this

lessMemoryMode

this

count

this

capacity

) {

vint

newCapacity

capacity

;

(

this

count

newCapacity

) {

void

newBuffer

this

AllocateBuffer

(

newCapacity

);

this

InitializeItemsByMove

(

this

AddressOf

(

newBuffer

this

AddressOf

(

this

buffer

this

count

);

this

ReleaseItems

(

this

buffer

this

count

);

this

DeallocateBuffer

(

this

buffer

);

this

capacity

newCapacity

;

this

buffer

newBuffer

; } } }

public

ListBase

() { }

ListBase

() {

this

ReleaseItems

(

this

buffer

this

count

);

this

DeallocateBuffer

(

this

buffer

); }

/// <summary>Set a preference of using memory.</summary>

/// <param name="mode">

/// Set to true (by default) to let the container actively reduce memories when there is too much room for unused elements.

/// This could happen after removing a lot of elements.

/// </param>

void

SetLessMemoryMode

(

bool

mode

) {

this

lessMemoryMode

mode

; }

/// <summary>Remove an element at a specified position.</summary>

/// <returns>Returns true if the element is removed. It will crash when the index is out of range.</returns>

/// <param name="index">The index of the element to remove.</param>

bool

RemoveAt

(

vint

index

) {

vint

previousCount

this

count

;

CHECK_ERROR(index >= 0 && index < this->count, L"ListBase<T, K>::RemoveAt(vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"ListBase<T, K>::RemoveAt(vint)#Argument index not in range."

);}

while

(

);

this

MoveItemsInTheSameBuffer

(

this

AddressOf

(

this

buffer

index

this

AddressOf

(

this

buffer

index

this

count

index

);

this

count

--;

ReleaseUnnecessaryBuffer

(

previousCount

);

return

true

; }

/// <summary>Remove contiguous elements at a specified psition.</summary>

/// <returns>Returns true if elements are removed. It will crash when the index or the size is out of range.</returns>

/// <param name="index">The index of the first element to remove.</param>

/// <param name="_count">The number of elements to remove.</param>

bool

RemoveRange

(

vint

index

vint

_count

) {

vint

previousCount

this

count

;

CHECK_ERROR(index >= 0 && index <= this->count, L"ListBase<T, K>::RemoveRange(vint, vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"ListBase<T, K>::RemoveRange(vint, vint)#Argument index not in range."

);}

while

(

);

CHECK_ERROR(index + _count >= 0 && index + _count <= this->count, L"ListBase<T,K>::RemoveRange(vint, vint)#Argument _count not in range.");

{

(!(

index

_count

index

_count

this

count

))

throw

Error

(

L"ListBase<T,K>::RemoveRange(vint, vint)#Argument _count not in range."

);}

while

(

);

this

MoveItemsInTheSameBuffer

(

this

AddressOf

(

this

buffer

index

this

AddressOf

(

this

buffer

index

_count

this

count

index

_count

);

this

count

_count

;

ReleaseUnnecessaryBuffer

(

previousCount

);

return

true

; }

/// <summary>Remove all elements.</summary>

/// <returns>Returns true if all elements are removed.</returns>

bool

Clear

() {

vint

previousCount

this

count

;

this

count

;

(

lessMemoryMode

) {

this

capacity

;

this

ReleaseItems

(

this

buffer

this

count

);

this

DeallocateBuffer

(

this

buffer

);

this

buffer

nullptr

; }

else

{

ReleaseUnnecessaryBuffer

(

previousCount

); }

return

true

; } };

/*********************************************************************** List ***********************************************************************/

/// <summary>List: linear container with dynamic size in runtime for unordered values. All elements are contiguous in memory.</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

KeyType

>::

Type

class

List

public

ListBase

> {

public

/// <summary>Create an empty list.</summary>

List

() =

default

;

/// <summary>Test does the list contain a value or not.</summary>

/// <returns>Returns true if the list contains the specified value.</returns>

/// <param name="item">The value to test.</param>

bool

Contains

(

const

item

)

const

{

return

IndexOf

(

item

) != -

; }

/// <summary>Get the position of a value in this list.</summary>

/// <returns>Returns the position of first element that equals to the specified value. Returns -1 if failed to find.</returns>

/// <param name="item">The value to find.</param>

vint

IndexOf

(

const

item

)

const

{

for

(

vint

;

this

count

;

++) {

(

this

ItemOf

(

) ==

item

) {

return

; } }

return

; }

/// <summary>Append a value at the end of the list.</summary>

/// <returns>The index of the added item.</returns>

/// <param name="item">The value to add.</param>

vint

Add

(

const

item

) {

return

Insert

(

this

count

item

); }

/// <summary>Insert a value at the specified position.</summary>

/// <returns>The index of the added item. It will crash if the index is out of range</returns>

/// <param name="index">The position to insert the value.</param>

/// <param name="item">The value to add.</param>

vint

Insert

(

vint

index

const

item

) {

CHECK_ERROR(index >= 0 && index <= this->count, L"List<T, K>::Insert(vint, const T&)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"List<T, K>::Insert(vint, const T&)#Argument index not in range."

);}

while

(

);

bool

uninitialized

false

;

this

MakeRoom

(

index

uninitialized

);

(

uninitialized

) {

new

this

ItemOf

(

index

))

(

item

); }

else

{

this

ItemOf

(

index

) =

item

; }

return

index

; }

/// <summary>Remove an element from the list. If multiple elements equal to the specified value, only the first one will be removed</summary>

/// <returns>Returns true if the element is removed.</returns>

/// <param name="item">The item to remove.</param>

bool

Remove

(

const

item

) {

vint

index

IndexOf

(

item

);

(

index

this

count

) {

this

RemoveAt

(

index

);

return

true

; }

else

{

return

false

; } }

/// <summary>Replace an element in the specified position.</summary>

/// <returns>Returns true if this operation succeeded. It will crash when the index is out of range</returns>

/// <param name="index">The position of the element to replace.</param>

/// <param name="item">The new value to replace.</param>

bool

Set

(

vint

index

const

item

) {

CHECK_ERROR(index >= 0 && index < this->count, L"List<T, K>::Set(vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"List<T, K>::Set(vint)#Argument index not in range."

);}

while

(

);

this

ItemOf

(

index

) =

item

;

return

true

; }

using

ListBase

>::

operator

[

]

;

/// <summary>Get the reference to the specified element.</summary>

/// <returns>The reference to the specified element. It will crash when the index is out of range.</returns>

/// <param name="index">The index of the element.</param>

operator

[

]

(

vint

index

) {

CHECK_ERROR(index >= 0 && index < this->count, L"List<T, K>::operator[](vint)#Argument index not in range.");

{

(!(

index

this

count

))

throw

Error

(

L"List<T, K>::operator[](vint)#Argument index not in range."

);}

while

(

);

return

this

ItemOf

(

index

); } };

/*********************************************************************** SortedList ***********************************************************************/

/// <summary>SortedList: linear container with dynamic size in runtime for ordered values. All elements are kept in order, and are contiguous in memory.</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

KeyType

>::

Type

class

SortedList

public

ListBase

> {

protected

/// <summary>Get the position of an element in this list by performing binary search.</summary>

/// <typeparam name="Key">Type of the element to find.</typeparam>

/// <returns>Returns the position. Returns -1 if it does not exist.</returns>

/// <param name="item">The element to find.</param>

/// <param name="index">

/// If the element exist, this argument returns one of the element that equals to the specified value.

/// If the element doesn not exist,

/// this argument returns either the greatest element that less than the specified value,

/// or the lest element that greater than the specified value.

/// </param>

template

typename

Key

vint

IndexOfInternal

(

const

Key

item

vint

index

)

const

{

vint

start

;

vint

end

this

count

;

index

= -

;

while

(

start

end

) {

index

start

+ (

end

start

) /

;

(

this

ItemOf

(

index

) ==

item

) {

return

index

; }

else

(

this

ItemOf

(

index

) >

item

) {

end

index

; }

else

{

start

index

; } }

return

; }

vint

Insert

(

vint

index

const

item

) {

bool

uninitialized

false

;

this

MakeRoom

(

index

uninitialized

);

(

uninitialized

) {

new

this

ItemOf

(

index

))

(

item

); }

else

{

this

ItemOf

(

index

) =

item

; }

return

index

; }

public

/// <summary>Create an empty list.</summary>

SortedList

() =

default

;

/// <summary>Test does the list contain a value or not.</summary>

/// <returns>Returns true if the list contains the specified value.</returns>

/// <param name="item">The value to test.</param>

bool

Contains

(

const

item

)

const

{

return

IndexOf

(

item

) != -

; }

/// <summary>Get the position of a value in this list.</summary>

/// <returns>Returns the position of first element that equals to the specified value. Returns -1 if failed to find.</returns>

/// <param name="item">The value to find.</param>

vint

IndexOf

(

const

item

)

const

{

vint

outputIndex

= -

;

return

IndexOfInternal

item

outputIndex

); }

/// <summary>Add a value at the correct position, all elements will be kept in order.</summary>

/// <returns>The index of the added item.</returns>

/// <param name="item">The value to add.</param>

vint

Add

(

const

item

) {

(

ArrayBase

>::

count

) {

return

Insert

(

item

); }

else

{

vint

outputIndex

= -

;

IndexOfInternal

item

outputIndex

);

CHECK_ERROR(outputIndex >= 0 && outputIndex < this->count, L"SortedList<T, K>::Add(const T&)#Internal error, index not in range.");

{

(!(

outputIndex

this

count

))

throw

Error

(

L"SortedList<T, K>::Add(const T&)#Internal error, index not in range."

);}

while

(

);

(

this

ItemOf

(

outputIndex

) <

item

) {

outputIndex

++; }

return

Insert

(

outputIndex

item

); } }

/// <summary>Remove an element from the list. If multiple elements equal to the specified value, only the first one will be removed</summary>

/// <returns>Returns true if the element is removed.</returns>

/// <param name="item">The item to remove.</param>

bool

Remove

(

const

item

) {

vint

index

IndexOf

(

item

);

(

index

ArrayBase

>::

count

) {

this

RemoveAt

(

index

);

return

true

; }

else

{

return

false

; } } };

/*********************************************************************** Special Containers ***********************************************************************/

template

typename

class

PushOnlyAllocator

public

Object

private

NotCopyable

{

protected

vint

blockSize

;

vint

allocatedSize

;

List

blocks

;

public

PushOnlyAllocator

(

vint

_blockSize

65536

) :blockSize(

_blockSize

) , allocatedSize(

) { }

PushOnlyAllocator

() {

for

(

vint

;

blocks

Count

();

++) {

delete

[]

blocks

[

]; } }

Get

(

vint

index

) {

(

index

allocatedSize

) {

return

; }

vint

row

index

blockSize

;

vint

column

index

blockSize

;

return

blocks

[

row

][

column

]; }

Create

() {

(

allocatedSize

blocks

Count

()*

blockSize

) {

blocks

Add

(

new

[

blockSize

]); }

vint

index

allocatedSize

++;

return

Get

(

index

); } };

namespace

bom_helper

{

struct

TreeNode

{

TreeNode

nodes

[

]; };

template

vint

Index

struct

Accessor

{

static

__forceinline

void

Get

(

TreeNode

root

vuint8_t

index

) {

root

) {

return

nullptr

; }

vint

fragmentIndex

= (

index

>> (

* (

Index

))) %

;

TreeNode

fragmentRoot

root

nodes

[

fragmentIndex

];

return

fragmentRoot

Accessor

Index

>::

Get

(

fragmentRoot

index

) :

; }

static

__forceinline

void

Set

(

TreeNode

root

vuint8_t

index

void

value

PushOnlyAllocator

TreeNode

allocator

) {

root

) {

root

allocator

Create

();

memset

(

root

nodes

sizeof

(

root

nodes

)); }

vint

fragmentIndex

= (

index

>> (

* (

Index

))) %

;

TreeNode

fragmentRoot

root

nodes

[

fragmentIndex

];

Accessor

Index

>::

Set

(

fragmentRoot

index

value

allocator

); } };

template

struct

Accessor

> {

static

__forceinline

void

Get

(

TreeNode

root

vuint8_t

index

) {

return

(

void

root

; }

static

__forceinline

void

Set

(

TreeNode

root

vuint8_t

index

void

value

PushOnlyAllocator

TreeNode

allocator

) { ((

void

*&)

root

) =

value

; } }; }

template

typename

class

ByteObjectMap

public

Object

private

NotCopyable

{

public

typedef

PushOnlyAllocator

bom_helper

TreeNode

Allocator

;

protected

bom_helper

TreeNode

root

nullptr

;

public

ByteObjectMap

() =

default

;

ByteObjectMap

() =

default

;

Get

(

vuint8_t

index

) {

return

(

bom_helper

Accessor

<>::

Get

(

root

index

); }

void

Set

(

vuint8_t

index

value

Allocator

allocator

) {

bom_helper

Accessor

<>::

Set

(

root

index

value

allocator

); } };

/*********************************************************************** Random Access ***********************************************************************/

namespace

randomaccess_internal

{

template

typename

struct

RandomAccessable

Array

>> {

static

const

bool

CanRead

true

;

static

const

bool

CanResize

true

; };

template

typename

struct

RandomAccessable

List

>> {

static

const

bool

CanRead

true

;

static

const

bool

CanResize

false

; };

template

typename

struct

RandomAccessable

SortedList

>> {

static

const

bool

CanRead

true

;

static

const

bool

CanResize

false

; }; } } }

#ifdef VCZH_CHECK_MEMORY_LEAKS_NEW

#define new VCZH_CHECK_MEMORY_LEAKS_NEW

#endif