The OpenD Programming Language

vector

Undocumented in source but is binding to C++. You might be able to learn more by searching the web for its name.

extern (C++)

struct vector (

T

Alloc

) {

template forward(args...) via import core.lifetime : forward, move, core_emplace = emplace;;

T move(T source) via import core.lifetime : forward, move, core_emplace = emplace;;

T* emplace(void[] chunk, Args args) via import core.lifetime : forward, move, core_emplace = emplace;;

alias size_type = size_t;

alias difference_type = ptrdiff_t;

alias value_type = T;

alias allocator_type = Alloc;

alias pointer = T*;

alias const_pointer = const(T)*;

alias length = size;

alias opDollar = length;

size_t[2] opSlice(size_t start, size_t end);

inout(T) opIndex(size_t index);

inout(T)[] opIndex(size_t[2] slice);

inout(T)[] opIndex();

vector opAssign(vector!(U, Alloc) s);

vector opAssign(T[] array);

void opIndexAssign(T val, size_t index);

void opIndexAssign(T val, size_t[2] slice);

void opIndexAssign(T[] val, size_t[2] slice);

void opIndexAssign(T val);

void opIndexAssign(T[] val);

void opIndexOpAssign(T val, size_t index);

void opIndexOpAssign(T val, size_t[2] slice);

void opIndexOpAssign(T[] val, size_t[2] slice);

void opIndexOpAssign(T val);

void opIndexOpAssign(T[] val);

inout(T) front();

inout(T) back();

vector opOpAssign(T item);

vector opOpAssign(T[] array);

void append(T[] array);

bool opEquals(That rhs);

static if(is(typeof((ref T a, ref T b) => a < b)))

int opCmp(That rhs);

size_t toHash();

void push_back(U element);

this(DefaultConstruct );

this(size_t count);

this(size_t count, T val);

this(T[] array);

version(CppRuntime_Microsoft)

inout(Alloc) get_allocator();

version(CppRuntime_Microsoft)

size_type max_size();

version(CppRuntime_Microsoft)

size_type size();

version(CppRuntime_Microsoft)

size_type capacity();

version(CppRuntime_Microsoft)

bool empty();

version(CppRuntime_Microsoft)

inout(T)* data();

version(CppRuntime_Microsoft)

inout(T)[] as_array();

version(CppRuntime_Microsoft)

inout(T) at(size_type i);

version(CppRuntime_Microsoft)

T emplace_back(Args args);

version(CppRuntime_Microsoft)

void reserve(size_type newCapacity);

version(CppRuntime_Microsoft)

void shrink_to_fit();

version(CppRuntime_Microsoft)

void pop_back();

version(CppRuntime_Microsoft)

void clear();

version(CppRuntime_Microsoft)

void resize(size_type newsize);

version(CppRuntime_Microsoft)

void resize(size_type newsize, T val);

version(CppRuntime_Microsoft)

void insert(size_t offset, T[] array);

}

Constructors

this this(): MSVC allocates on default initialisation in debug, which can't be modelled by D struct
this this(DefaultConstruct )
this this(size_t count)
this this(size_t count, T val)
this this(T[] array)

Destructor

~this ~this()

Postblit

this(this) this(this)

Members

Aliases

allocator_type alias allocator_type = Alloc
const_pointer alias const_pointer = const(T)*
difference_type alias difference_type = ptrdiff_t
length alias length = size
opDollar alias opDollar = length
pointer alias pointer = T*
size_type alias size_type = size_t
value_type alias value_type = T

Functions

append void append(T[] array)
as_array inout(T)[] as_array()
at inout(T) at(size_type i)
back inout(T) back()
capacity size_type capacity()
clear void clear()
data inout(T)* data()
emplace_back T emplace_back(Args args)
empty bool empty()
front inout(T) front()
get_allocator inout(Alloc) get_allocator()
insert void insert(size_t offset, T[] array)
max_size size_type max_size()
opAssign vector opAssign(vector!(U, Alloc) s)
opAssign vector opAssign(T[] array)
opCmp int opCmp(That rhs): Performs lexicographical comparison.
opEquals bool opEquals(That rhs): Performs elementwise equality check.
opIndex inout(T) opIndex(size_t index)
opIndex inout(T)[] opIndex(size_t[2] slice)
opIndex inout(T)[] opIndex()
opIndexAssign void opIndexAssign(T val, size_t index)
opIndexAssign void opIndexAssign(T val, size_t[2] slice)
opIndexAssign void opIndexAssign(T[] val, size_t[2] slice)
opIndexAssign void opIndexAssign(T val)
opIndexAssign void opIndexAssign(T[] val)
opIndexOpAssign void opIndexOpAssign(T val, size_t index)
opIndexOpAssign void opIndexOpAssign(T val, size_t[2] slice)
opIndexOpAssign void opIndexOpAssign(T[] val, size_t[2] slice)
opIndexOpAssign void opIndexOpAssign(T val)
opIndexOpAssign void opIndexOpAssign(T[] val)
opOpAssign vector opOpAssign(T item)
opOpAssign vector opOpAssign(T[] array)
opSlice size_t[2] opSlice(size_t start, size_t end)
pop_back void pop_back()
push_back void push_back(U element)
reserve void reserve(size_type newCapacity)
resize void resize(size_type newsize)
resize void resize(size_type newsize, T val)
shrink_to_fit void shrink_to_fit()
size size_type size()
toHash size_t toHash(): Hash to allow vectors to be used as keys for built-in associative arrays. **The result will generally not be the same as C++ std::hash<std::vector<T>>.**

Meta

Source

See Implementation

core stdcpp vector structs

vector