DynamicArray

Array type with deterministic control of memory. The memory allocated for the array is reclaimed as soon as possible; there is no reliance on the garbage collector. Array uses malloc, realloc and free for managing its own memory.

Use std.bitmanip.BitArray for array container storing boolean values.

TODO optimize by making members templates. 0.579s before, eval-dwim: 0.67s

TODO Add OutputRange.writer support as https://github.com/burner/StringBuffer/blob/master/source/stringbuffer.d#L45

TODO Use std.traits.areCopyCompatibleArrays

@safe

struct DynamicArray (

T

alias Allocator = null

CapacityType = size_t

) if (

!is(Unqual!T == bool) &&

(

is(CapacityType == ulong) ||

is(CapacityType == uint)

)

) {

eponymoustemplate isElementAssignable(U);

static typeof(this) withLength(size_t initialLength);

static typeof(this) withCapacity(size_t initialCapacity);

static typeof(this) withLengthElementValue(size_t length, T elementValue);

static typeof(this) emplaceWithMovedElements(typeof(this)* thatPtr, T[] elements);

static typeof(this) emplaceWithCopiedElements(typeof(this)* thatPtr, const(T)[] elements);

DynamicArray!(Unqual!T, Allocator, CapacityType) dup();

this(U[] values);

this(U[n] values);

this(R values);

static typeof(this) withElementsOfRange_untested(R values);

void clear();

bool opEquals(typeof(this) rhs);

bool opEquals(U[] rhs);

hash_t toHash();

void toString(void delegate(scope const(char)[]) sink);

bool empty();

size_t length();

void length(size_t newLength);

size_t capacity();

void reserve(size_t minimumCapacity);

inout(T) opIndex(size_t i);

inout(T)[] opSlice(size_t i, size_t j);

inout(T)[] opSlice();

T opIndexAssign(U value, size_t i);

T[] opSliceAssign(U value);

T[] opSliceAssign(U value, size_t i, size_t j);

inout(T) front();

inout(T) back();

void insertBackMove(T value);

void insertBack(T value);

void insertBack(U[] values);

void insertBack1(T value);

void insertBack(R elements);

alias put = insertBack;

void popBack();

void popBackN(size_t n);

void popAt(size_t index);

T moveAt(size_t index);

T frontPop();

void opOpAssign(T value);

void opOpAssign(U[] values);

void opOpAssign(R values);

inout(T)* ptr();

}

Constructors

this this(T value): Construct from uncopyable element value.
this this(U value): Construct from copyable element value.
this this(U[] values): Construct from the element(s) of the dynamic array values.
this this(U[n] values)
this(R values): Construct from the n number of element(s) in the static array values.

Destructor

~this ~this(): Destruct.

Postblit

this(this) this(this): No default copying.

Members

Aliases

put alias put = insertBack: Insert the elements elements into the end of the array.

Enums

isElementAssignable eponymoustemplate isElementAssignable(U): Is true if U can be assign to the element type T of this.

Functions

back inout(T) back(): Get reference to back element.
backPop T backPop(): Pop back element and return it.
capacity size_t capacity(): Get capacity.
clear void clear(): Empty.
dup DynamicArray!(Unqual!T, Allocator, CapacityType) dup()
empty bool empty(): Check if empty.
front inout(T) front(): Get reference to front element.
frontPop T frontPop(): Move element at front.
insertBack void insertBack(T value): Insert unmoveable value into the end of the array.
insertBack void insertBack(U[] values): Insert the elements values into the end of the array.
insertBack void insertBack(R elements): Insert the elements elements into the end of the array.
insertBack1 void insertBack1(T value): Insert value into the end of the array.
insertBackMove void insertBackMove(T value): Move value into the end of the array.
length size_t length(): Get length.
length void length(size_t newLength): Set length to newLength.
moveAt T moveAt(size_t index): Move element at index to return.
opEquals bool opEquals(typeof(this) rhs)
bool opEquals(U[] rhs): Comparison for equality.
opIndex inout(T) opIndex(size_t i): Index support.
opIndexAssign T opIndexAssign(U value, size_t i): Index assignment support.
opOpAssign void opOpAssign(T value)
void opOpAssign(U[] values)
void opOpAssign(R values): Forwards to insertBack(values).
opSlice inout(T)[] opSlice(size_t i, size_t j)
inout(T)[] opSlice(): Slice support.
opSliceAssign T[] opSliceAssign(U value)
T[] opSliceAssign(U value, size_t i, size_t j): Slice assignment support.
popAt void popAt(size_t index): Pop element at index.
popBack void popBack(): Remove last value fromm the end of the array.
popBackN void popBackN(size_t n): Rmove n last values from the end of the array.
ptr inout(T)* ptr(): Unsafe access to pointer.
reserve void reserve(size_t minimumCapacity): Ensures sufficient capacity to accommodate for minimumCapacity number of elements. If minimumCapacity < capacity, this method does nothing.
toHash hash_t toHash(): Calculate D associative array (AA) key hash.
toString void toString(void delegate(scope const(char)[]) sink): Construct a string representation of this at sink.

Static functions

emplaceWithCopiedElements typeof(this) emplaceWithCopiedElements(typeof(this)* thatPtr, const(T)[] elements): Emplace thatPtr with elements copied from elements.
emplaceWithMovedElements typeof(this) emplaceWithMovedElements(typeof(this)* thatPtr, T[] elements): Emplace thatPtr with elements moved from elements.
withCapacity typeof(this) withCapacity(size_t initialCapacity)
withElementsOfRange_untested typeof(this) withElementsOfRange_untested(R values): Construct from the elements values.
withLength typeof(this) withLength(size_t initialLength)
withLengthElementValue typeof(this) withLengthElementValue(size_t length, T elementValue): Construct using - initial length length, - and value of all elements elementValue.

See Also

https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md

Meta

Source

See Implementation

nxt dynamic_array functions

remove

structs