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)

)

) {

import core.internal.traits : hasElaborateDestructor;;

import std.range.primitives : isInputRange, ElementType, hasLength, hasSlicing, isInfinite;;

import std.range.primitives : isInputRange, ElementType, hasLength, hasSlicing, isInfinite;;

import std.range.primitives : isInputRange, ElementType, hasLength, hasSlicing, isInfinite;;

import std.range.primitives : isInputRange, ElementType, hasLength, hasSlicing, isInfinite;;

import std.range.primitives : isInputRange, ElementType, hasLength, hasSlicing, isInfinite;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import std.traits : hasIndirections, hasAliasing, isMutable, TemplateOf, isArray, isAssignable, isType, hasFunctionAttributes, isIterable;;

import core.lifetime : emplace, move, moveEmplace;;

import core.lifetime : emplace, move, moveEmplace;;

import core.lifetime : emplace, move, moveEmplace;;

void* malloc(size_t size) via import nxt.qcmeman : malloc, calloc, realloc, free, gc_addRange, gc_removeRange;;

void* calloc(size_t nmemb, size_t size) via import nxt.qcmeman : malloc, calloc, realloc, free, gc_addRange, gc_removeRange;;

void* realloc(void* ptr, size_t size) via import nxt.qcmeman : malloc, calloc, realloc, free, gc_addRange, gc_removeRange;;

void free(void* ptr) via import nxt.qcmeman : malloc, calloc, realloc, free, gc_addRange, gc_removeRange;;

void gc_addRange(void* p, size_t sz, TypeInfo ti) via import nxt.qcmeman : malloc, calloc, realloc, free, gc_addRange, gc_removeRange;;

void gc_removeRange(void* p) via import nxt.qcmeman : malloc, calloc, realloc, free, gc_addRange, gc_removeRange;;

template mustAddGCRange(T) via import nxt.container_traits : mustAddGCRange, needsMove;;

enum bool needsMove(T); via import nxt.container_traits : mustAddGCRange, needsMove;;

eponymoustemplate isElementAssignable(U);

static typeof(this) withLength(size_t initialLength);

static typeof(this) withCapacity(size_t initialCapacity);

static if(__traits(isCopyable, T))

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);

static if(__traits(isCopyable, T) && !is(T == union))

static typeof(this) withElements(T[] elements);

static if(__traits(isCopyable, T) && !is(T == union))

DynamicArray!(Unqual!T, Allocator, CapacityType) dup [@property getter];

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();

static if(__traits(isCopyable, T))

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

bool empty [@property getter];

size_t length [@property getter];

alias opDollar = length;

size_t length [@property setter];

size_t capacity [@property getter];

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);

void opOpAssign(typeof(this) 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

opDollar alias opDollar = length: Undocumented in source.
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.
clear void clear(): 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.
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).
opOpAssign void opOpAssign(typeof(this) values): Undocumented in source. Be warned that the author may not have intended to support it.
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.

Properties

capacity size_t capacity [@property getter]: Get capacity.
dup DynamicArray!(Unqual!T, Allocator, CapacityType) dup [@property getter]
empty bool empty [@property getter]: Check if empty.
length size_t length [@property getter]: Get length.
length size_t length [@property setter]: Set length to newLength.

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)
withElements typeof(this) withElements(T[] elements): Undocumented in source. Be warned that the author may not have intended to support it.
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