OperationEnumerable.h

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

#ifndef VCZH_COLLECTIONS_OPERATIONENUMERABLE

#define VCZH_COLLECTIONS_OPERATIONENUMERABLE

#include "List.h"

#include "../Pointer.h"

namespace

{

namespace

collections

{

/*********************************************************************** EmptyEnumerable ***********************************************************************/

template

typename

class

EmptyEnumerable

public

Object

public

IEnumerable

> {

private

class

Enumerator

public

Object

public

virtual

IEnumerator

> {

IEnumerator

Clone

()

const

override

{

return

new

Enumerator

; }

const

Current

()

const

override

{

CHECK_FAIL(L"EmptyEnumerable<T>::Enumerator::Current()#This collection is empty.");

{

throw

Error

(

L"EmptyEnumerable<T>::Enumerator::Current()#This collection is empty."

);}

while

(

);

}

vint

Index

()

const

override

{

return

; }

bool

()

override

{

return

false

; }

void

Reset

()

override

{ }

bool

Evaluated

()

const

override

{

return

true

; } };

public

IEnumerator

CreateEnumerator

()

const

{

return

new

Enumerator

; } };

/*********************************************************************** RangeEnumerator ***********************************************************************/

template

typename

class

RangeEnumerator

public

Object

public

virtual

IEnumerator

> {

protected

start

;

count

;

current

;

public

RangeEnumerator

(

_start

_count

_current

) :start(

_start

) ,count(

_count

) ,current(

_current

) { }

RangeEnumerator

(

_start

_count

) :start(

_start

) ,count(

_count

) ,current(

_start

) { }

IEnumerator

Clone

()

const

override

{

return

new

RangeEnumerator

(

start

count

current

); }

const

Current

()

const

override

{

return

current

; }

Index

()

const

override

{

return

current

start

; }

bool

()

override

{

(

start

current

start

count

) {

current

++;

return

true

; }

else

{

return

false

; } }

void

Reset

()

override

{

current

start

; }

bool

Evaluated

()

const

override

{

return

true

; } };

/*********************************************************************** ContainerEnumerator ***********************************************************************/

template

typename

TContainer

class

ContainerEnumerator

public

Object

public

virtual

IEnumerator

> {

private

Ptr

TContainer

container

;

vint

index

;

public

ContainerEnumerator

(

Ptr

TContainer

_container

vint

_index

) {

container

_container

;

index

_index

; }

IEnumerator

Clone

()

const

override

{

return

new

ContainerEnumerator

(

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

; } };

/*********************************************************************** CompareEnumerable ***********************************************************************/

/// <summary>Compare two enumerables.</summary>

/// <typeparam name="T">Type of elements in the first enumerable.</typeparam>

/// <typeparam name="U">Type of elements in the second enumerable.</typeparam>

/// <returns>

/// Returns a positive value when the first enumerable is greater than the second enumerable.

/// Returns a negative value when the first enumerable is lesser than the second enumerable.

/// Returns zero when the two enumerables equal.

/// </returns>

/// <param name="a">The first enumerable to compare.</param>

/// <param name="b">The second enumerable to compare.</param>

/// <remarks>

/// The comparison result is similar to comparing two strings.

/// When an enumerable contains no value but another one does, the empty one is lesser.

/// When an enumerable is the prefix of another one, the prefix is lesser.

/// When two enumerable contain the same values in the same order, they equals.

/// In other cases, the results represents the comparison result of the first pair of inequal values in enumerables.

/// </remarks>

template

typename

vint

CompareEnumerable

(

const

IEnumerable

const

IEnumerable

) {

Ptr

IEnumerator

ator

CreateEnumerator

();

Ptr

IEnumerator

btor

CreateEnumerator

();

while

(

true

) {

bool

ator

();

bool

btor

();

(

&& !

)

return

;

)

return

;

&& !

)

break

;

const

ator

Current

();

const

btor

Current

();

(

) {

return

; }

else

(

) {

return

; } }

return

; }

template

typename

struct

SortedListOperations

{

static

bool

Contains

(

const

SortedList

items

const

item

) {

return

items

Contains

(

item

); } };

template

typename

struct

SortedListOperations

Ptr

>> {

static

bool

Contains

(

const

SortedList

Ptr

>>&

items

const

Ptr

item

) {

return

items

Contains

(

item

Obj

()); } }; } }

#endif