OperationSequence.h

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

#ifndef VCZH_COLLECTIONS_OPERATIONSEQUENCE

#define VCZH_COLLECTIONS_OPERATIONSEQUENCE

#include "OperationEnumerable.h"

#include "OperationCopyFrom.h"

#include "List.h"

namespace

{

namespace

collections

{

/*********************************************************************** Take ***********************************************************************/

template

typename

class

TakeEnumerator

public

virtual

IEnumerator

> {

protected

IEnumerator

enumerator

;

vint

count

;

public

TakeEnumerator

(

IEnumerator

_enumerator

vint

_count

) :enumerator(

_enumerator

) ,count(

_count

) { }

TakeEnumerator

() {

delete

enumerator

; }

IEnumerator

Clone

()

const

override

{

return

new

TakeEnumerator

(

enumerator

Clone

(),

count

); }

const

Current

()

const

override

{

return

enumerator

Current

(); }

vint

Index

()

const

override

{

return

enumerator

Index

(); }

bool

()

override

{

(

enumerator

Index

()>=

count

)

return

false

;

return

enumerator

(); }

void

Reset

()

override

{

enumerator

Reset

(); }

bool

Evaluated

()

const

override

{

return

enumerator

Evaluated

(); } };

/*********************************************************************** Skip ***********************************************************************/

template

typename

class

SkipEnumerator

public

virtual

IEnumerator

> {

protected

IEnumerator

enumerator

;

vint

count

;

bool

skipped

;

public

SkipEnumerator

(

IEnumerator

_enumerator

vint

_count

bool

_skipped

false

) :enumerator(

_enumerator

) ,count(

_count

) ,skipped(

_skipped

) { }

SkipEnumerator

() {

delete

enumerator

; }

IEnumerator

Clone

()

const

override

{

return

new

SkipEnumerator

(

enumerator

Clone

(),

count

skipped

); }

const

Current

()

const

override

{

return

enumerator

Current

(); }

vint

Index

()

const

override

{

return

enumerator

Index

()-

count

; }

bool

()

override

{

skipped

) {

skipped

true

;

for

(

vint

;

count

;

++) {

enumerator

()) {

return

false

; } } }

return

enumerator

(); }

void

Reset

()

override

{

enumerator

Reset

();

skipped

false

; }

bool

Evaluated

()

const

override

{

return

enumerator

Evaluated

(); } };

/*********************************************************************** Repeat ***********************************************************************/

template

typename

class

RepeatEnumerator

public

virtual

IEnumerator

> {

protected

IEnumerator

enumerator

;

vint

count

;

vint

index

;

vint

repeatedCount

;

public

RepeatEnumerator

(

IEnumerator

_enumerator

vint

_count

vint

_index

vint

_repeatedCount

) :enumerator(

_enumerator

) ,count(

_count

) ,index(

_index

) ,repeatedCount(

_repeatedCount

) { }

RepeatEnumerator

() {

delete

enumerator

; }

IEnumerator

Clone

()

const

override

{

return

new

RepeatEnumerator

(

enumerator

Clone

(),

count

index

repeatedCount

); }

const

Current

()

const

override

{

return

enumerator

Current

(); }

vint

Index

()

const

override

{

return

index

; }

bool

()

override

{

while

(

repeatedCount

count

) {

(

enumerator

()) {

index

++;

return

true

; }

repeatedCount

++;

enumerator

Reset

(); }

return

false

; }

void

Reset

()

override

{

enumerator

Reset

();

index

;

repeatedCount

; }

bool

Evaluated

()

const

override

{

return

enumerator

Evaluated

(); } };

/*********************************************************************** Distinct ***********************************************************************/

template

typename

class

DistinctEnumerator

public

virtual

IEnumerator

> {

protected

IEnumerator

enumerator

;

SortedList

distinct

;

lastValue

;

public

DistinctEnumerator

(

IEnumerator

_enumerator

) :enumerator(

_enumerator

) { }

DistinctEnumerator

(

const

DistinctEnumerator

_enumerator

) :lastValue(

_enumerator

lastValue

) {

enumerator

_enumerator

enumerator

Clone

();

CopyFrom

(

distinct

_enumerator

distinct

); }

DistinctEnumerator

() {

delete

enumerator

; }

IEnumerator

Clone

()

const

override

{

return

new

DistinctEnumerator

this

); }

const

Current

()

const

override

{

return

lastValue

; }

vint

Index

()

const

override

{

return

distinct

Count

()-

; }

bool

()

override

{

while

(

enumerator

()) {

const

current

enumerator

Current

();

SortedListOperations

>::

Contains

(

distinct

current

)) {

lastValue

current

;

distinct

Add

(

current

);

return

true

; } }

return

false

; }

void

Reset

()

override

{

enumerator

Reset

();

distinct

Clear

(); } };

/*********************************************************************** Reverse ***********************************************************************/

template

typename

class

ReverseEnumerator

public

virtual

IEnumerator

> {

protected

List

cache

;

vint

index

;

public

ReverseEnumerator

(

const

IEnumerable

enumerable

) :index(-

) {

CopyFrom

(

cache

enumerable

); }

ReverseEnumerator

(

const

ReverseEnumerator

_enumerator

) :index(

_enumerator

index

) {

CopyFrom

(

cache

_enumerator

cache

); }

ReverseEnumerator

() { }

IEnumerator

Clone

()

const

override

{

return

new

ReverseEnumerator

this

); }

const

Current

()

const

override

{

return

cache

Get

(

cache

Count

()-

index

); }

vint

Index

()

const

override

{

return

index

; }

bool

()

override

{

index

++;

return

index

cache

Count

(); }

void

Reset

()

override

{

index

; }

bool

Evaluated

()

const

override

{

return

true

; } };

/*********************************************************************** FromIterator ***********************************************************************/

template

typename

class

FromIteratorEnumerable

public

Object

public

IEnumerable

> {

private

class

Enumerator

public

Object

public

IEnumerator

> {

private

begin

;

end

;

current

;

public

Enumerator

(

_begin

_end

_current

) :begin(

_begin

) ,end(

_end

) ,current(

_current

) { }

IEnumerator

Clone

()

const

override

{

return

new

Enumerator

(

begin

end

current

); }

const

Current

()

const

override

{

return

current

; }

vint

Index

()

const

override

{

return

current

begin

; }

bool

()

override

{

current

++;

return

begin

current

end

; }

void

Reset

()

override

{

current

begin

; }

bool

Evaluated

()

const

override

{

return

true

; } };

private

begin

;

end

;

public

IEnumerator

CreateEnumerator

()

const

{

return

new

Enumerator

(

begin

end

begin

); }

FromIteratorEnumerable

(

_begin

_end

) :begin(

_begin

) ,end(

_end

) { }

FromIteratorEnumerable

(

const

FromIteratorEnumerable

enumerable

) :begin(

enumerable

begin

) ,end(

enumerable

end

) { } };

template

typename

class

FromIterator

{

public

template

typename

static

FromIteratorEnumerable

Wrap

(

begin

end

) {

return

FromIteratorEnumerable

begin

end

); } };

template

typename

FromIteratorEnumerable

const

FromPointer

(

const

begin

const

end

) {

return

FromIteratorEnumerable

const

*>(

begin

end

); }

template

typename

int

size

FromIteratorEnumerable

FromArray

(

items

)[

size

]) {

return

FromIteratorEnumerable

*>(&

items

[

], &

items

[

size

]); } } }

#endif