OperationCopyFrom.h

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

#ifndef VCZH_COLLECTIONS_OPERATIONCOPYFROM

#define VCZH_COLLECTIONS_OPERATIONCOPYFROM

#include "Interfaces.h"

namespace

{

namespace

collections

{

/*********************************************************************** Copy Functions for Containers ***********************************************************************/

namespace

copyfrom_internal

{

using

namespace

randomaccess_internal

;

template

typename

bool

DsRA

bool

SsRA

struct

CopyFromAlgorithm

{ };

template

typename

struct

CopyFromAlgorithm

true

> {

static

void

Perform

(

const

bool

append

) {

vint

copyCount

RandomAccess

>::

GetCount

(

);

vint

index

append

RandomAccess

>::

GetCount

(

);

vint

resizeCount

index

copyCount

;

RandomAccess

>::

SetCount

(

resizeCount

);

for

(

vint

;

copyCount

;

++) {

RandomAccess

>::

SetValue

(

index

RandomAccess

>::

GetValue

(

)); } } };

template

typename

struct

CopyFromAlgorithm

false

true

> {

static

void

Perform

(

const

bool

append

) {

append

) {

.Clear(); }

vint

copyCount

RandomAccess

>::

GetCount

(

);

for

(

vint

;

copyCount

;

++) {

RandomAccess

>::

AppendValue

(

RandomAccess

>::

GetValue

(

)); } } };

template

typename

struct

CopyFromAlgorithm

true

false

> {

static

void

Perform

(

const

bool

append

) {

Ptr

IEnumerator

typename

::ElementType>>

enumerator

;

vint

copyCount

;

enumerator

.CreateEnumerator();

while

(

enumerator

()) {

copyCount

++; }

vint

index

append

RandomAccess

>::

GetCount

(

);

vint

resizeCount

index

copyCount

;

RandomAccess

>::

SetCount

(

resizeCount

);

enumerator

.CreateEnumerator();

while

(

enumerator

()) {

RandomAccess

>::

SetValue

(

index

++,

enumerator

Current

()); } } };

template

typename

struct

CopyFromAlgorithm

false

> {

static

void

Perform

(

const

bool

append

) {

append

) {

.Clear(); }

Ptr

IEnumerator

typename

::ElementType>>

enumerator

.CreateEnumerator();

while

(

enumerator

()) {

RandomAccess

>::

AppendValue

(

enumerator

Current

()); } } };

template

typename

struct

Slice

{

const

items

;

vint

count

; }; }

namespace

randomaccess_internal

{

template

typename

struct

RandomAccessable

copyfrom_internal

Slice

>> {

static

const

bool

CanRead

true

;

static

const

bool

CanResize

true

; };

template

typename

struct

RandomAccess

copyfrom_internal

Slice

>> {

static

vint

GetCount

(

const

copyfrom_internal

Slice

) {

return

count

; }

static

const

GetValue

(

const

copyfrom_internal

Slice

vint

index

) {

return

items

[

index

]; } }; }

/// <summary>Copy containers.</summary>

/// <typeparam name="Ds">Type of the target container.</typeparam>

/// <typeparam name="Ss">Type of the source container.</typeparam>

/// <param name="ds">The target container.</param>

/// <param name="ss">The source container.</param>

/// <param name="append">Set to true to perform appending instead of replacing.</param>

template

typename

void

CopyFrom

(

const

bool

append

false

) {

copyfrom_internal

CopyFromAlgorithm

randomaccess_internal

RandomAccessable

>::

CanResize

randomaccess_internal

RandomAccessable

>::

CanRead

>::

Perform

(

append

); }

/// <summary>Copy containers.</summary>

/// <typeparam name="Ds">Type of the target container.</typeparam>

/// <typeparam name="S">Type of values in the source container.</typeparam>

/// <param name="ds">The target container.</param>

/// <param name="buffer">Pointer to source values.</param>

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

/// <param name="append">Set to true to perform appending instead of replacing.</param>

template

typename

void

CopyFrom

(

const

buffer

vint

count

bool

append

false

) {

copyfrom_internal

Slice

slice

= {

buffer

count

};

CopyFrom

(

slice

append

); }

/// <summary>Copy containers.</summary>

/// <typeparam name="Ds">Type of the target container.</typeparam>

/// <typeparam name="S">Type of values in the source container.</typeparam>

/// <param name="ds">The target container.</param>

/// <param name="begin">Pointer to the first source value.</param>

/// <param name="end">Pointer to the value after the last source value.</param>

/// <param name="append">Set to true to perform appending instead of replacing.</param>

template

typename

void

CopyFrom

(

const

begin

const

end

bool

append

false

) {

copyfrom_internal

Slice

slice

= {

begin

end

begin

};

CopyFrom

(

slice

append

); } } }

#endif