Mergul
d0fcdba6cd
-added export attributes (required by windows to make DLL library, not work at now due to DMD bugs) -interface D files to import
400 lines
8.1 KiB
D
400 lines
8.1 KiB
D
module ecs.vector;
|
|
|
|
import core.bitop;
|
|
import core.stdc.stdlib : free, malloc;
|
|
import core.stdc.string : memcpy, memset;
|
|
import std.algorithm : swap;
|
|
import std.conv : emplace;
|
|
import std.traits : hasMember, isCopyable, TemplateOf, Unqual;
|
|
|
|
export @nogc @safe nothrow pure size_t nextPow2(size_t num) {
|
|
return 1 << bsr(num) + 1;
|
|
}
|
|
|
|
__gshared size_t gVectorsCreated = 0;
|
|
__gshared size_t gVectorsDestroyed = 0;
|
|
|
|
struct Vector(T) {
|
|
T[] array;
|
|
size_t used;
|
|
public:
|
|
|
|
export this()(T t) {
|
|
add(t);
|
|
}
|
|
|
|
export this(X)(X[] t) if (is(Unqual!X == Unqual!T)) {
|
|
add(t);
|
|
|
|
}
|
|
|
|
static if (isCopyable!T) {
|
|
export this(this) {
|
|
T[] tmp = array[0 .. used];
|
|
array = null;
|
|
used = 0;
|
|
add(tmp);
|
|
}
|
|
} else {
|
|
@disable this(this);
|
|
}
|
|
|
|
export ~this() {
|
|
clear();
|
|
}
|
|
|
|
export void clear() {
|
|
removeAll();
|
|
}
|
|
|
|
export void removeAll() {
|
|
if (array !is null) {
|
|
foreach (ref el; array[0 .. used]) {
|
|
destroy(el);
|
|
}
|
|
freeData(cast(void[]) array);
|
|
gVectorsDestroyed++;
|
|
}
|
|
array = null;
|
|
used = 0;
|
|
}
|
|
|
|
export bool empty() {
|
|
return (used == 0);
|
|
}
|
|
|
|
export size_t length() {
|
|
return used;
|
|
}
|
|
|
|
export void length(size_t newLength) {
|
|
if (newLength > used) {
|
|
reserve(newLength);
|
|
foreach (ref el; array[used .. newLength]) {
|
|
emplace(&el);
|
|
}
|
|
} else {
|
|
foreach (ref el; array[newLength .. used]) {
|
|
destroy(el);
|
|
}
|
|
}
|
|
used = newLength;
|
|
}
|
|
|
|
export void reset() {
|
|
used = 0;
|
|
}
|
|
|
|
export void reserve(size_t numElements) {
|
|
if (numElements > array.length) {
|
|
extend(numElements);
|
|
}
|
|
}
|
|
|
|
export size_t capacity() {
|
|
return array.length - used;
|
|
}
|
|
|
|
export void extend(size_t newNumOfElements) {
|
|
auto oldArray = manualExtend(array, newNumOfElements);
|
|
if (oldArray !is null) {
|
|
freeData(oldArray);
|
|
}
|
|
}
|
|
|
|
export @nogc void freeData(void[] data) {
|
|
// 0x0F probably invalid value for pointers and other types
|
|
memset(data.ptr, 0x0F, data.length); // Makes bugs show up xD
|
|
free(data.ptr);
|
|
}
|
|
|
|
export static void[] manualExtend(ref T[] array, size_t newNumOfElements = 0) {
|
|
if (newNumOfElements == 0)
|
|
newNumOfElements = 2;
|
|
if (array.length == 0)
|
|
gVectorsCreated++;
|
|
T[] oldArray = array;
|
|
size_t oldSize = oldArray.length * T.sizeof;
|
|
size_t newSize = newNumOfElements * T.sizeof;
|
|
T* memory = cast(T*) malloc(newSize);
|
|
memcpy(cast(void*) memory, cast(void*) oldArray.ptr, oldSize);
|
|
array = memory[0 .. newNumOfElements];
|
|
return cast(void[]) oldArray;
|
|
}
|
|
|
|
export Vector!T copy()() {
|
|
Vector!T duplicate;
|
|
duplicate.reserve(used);
|
|
duplicate ~= array[0 .. used];
|
|
return duplicate;
|
|
}
|
|
|
|
export bool canAddWithoutRealloc(uint elemNum = 1) {
|
|
return used + elemNum <= array.length;
|
|
}
|
|
|
|
export void add()(T t) {
|
|
if (used >= array.length) {
|
|
extend(nextPow2(used + 1));
|
|
}
|
|
emplace(&array[used], t);
|
|
used++;
|
|
}
|
|
|
|
/// Add element at given position moving others
|
|
export void add()(T t, size_t pos) {
|
|
assert(pos <= used);
|
|
if (used >= array.length) {
|
|
extend(array.length * 2);
|
|
}
|
|
foreach_reverse (size_t i; pos .. used) {
|
|
//swap(array[i + 1], array[i]);
|
|
array[i+1] = array[i];
|
|
}
|
|
emplace(&array[pos], t);
|
|
used++;
|
|
}
|
|
|
|
export void add(X)(X[] t) if (is(Unqual!X == Unqual!T)) {
|
|
if (used + t.length > array.length) {
|
|
extend(nextPow2(used + t.length));
|
|
}
|
|
foreach (i; 0 .. t.length) {
|
|
emplace(&array[used + i], t[i]);
|
|
}
|
|
used += t.length;
|
|
}
|
|
|
|
export void remove(size_t elemNum) {
|
|
destroy(array[elemNum]);
|
|
swap(array[elemNum], array[used - 1]);
|
|
used--;
|
|
}
|
|
|
|
export void removeStable()(size_t elemNum) {
|
|
used--;
|
|
foreach (i; 0 .. used) {
|
|
array[i] = array[i + 1];
|
|
}
|
|
}
|
|
|
|
export bool tryRemoveElement()(T elem) {
|
|
foreach (i, ref el; array[0 .. used]) {
|
|
if (el == elem) {
|
|
remove(i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export void removeElement()(T elem) {
|
|
bool ok = tryRemoveElement(elem);
|
|
assert(ok, "There is no such an element in vector");
|
|
}
|
|
|
|
export ref T opIndex(size_t elemNum) {
|
|
assert(elemNum < used, "Range violation [index]");
|
|
return array.ptr[elemNum];
|
|
}
|
|
|
|
export auto opSlice() {
|
|
return array.ptr[0 .. used];
|
|
}
|
|
|
|
export T[] opSlice(size_t x, size_t y) {
|
|
assert(y <= used);
|
|
return array.ptr[x .. y];
|
|
}
|
|
|
|
export size_t opDollar() {
|
|
return used;
|
|
}
|
|
|
|
export void opAssign(X)(X[] slice) {
|
|
reset();
|
|
this ~= slice;
|
|
}
|
|
|
|
export void opOpAssign(string op)(T obj) {
|
|
static assert(op == "~");
|
|
add(obj);
|
|
}
|
|
|
|
export void opOpAssign(string op, X)(X[] obj) {
|
|
static assert(op == "~");
|
|
add(obj);
|
|
}
|
|
|
|
export void opIndexAssign()(T obj, size_t elemNum) {
|
|
assert(elemNum < used, "Range viloation");
|
|
array[elemNum] = obj;
|
|
}
|
|
|
|
export void opSliceAssign()(T[] obj, size_t a, size_t b) {
|
|
assert(b <= used && a <= b, "Range viloation");
|
|
array.ptr[a .. b] = obj;
|
|
}
|
|
|
|
export bool opEquals()(auto ref const Vector!(T) r) const {
|
|
return used == r.used && array.ptr[0 .. used] == r.array.ptr[0 .. r.used];
|
|
}
|
|
|
|
export size_t toHash() const nothrow @trusted {
|
|
return hashOf(cast(Unqual!(T)[]) array.ptr[0 .. used]);
|
|
}
|
|
|
|
import std.format : FormatSpec, formatValue;
|
|
|
|
/**
|
|
* Preety print
|
|
*/
|
|
export void toString(scope void delegate(const(char)[]) sink, FormatSpec!char fmt) {
|
|
static if (__traits(compiles, formatValue(sink, array[0 .. used], fmt))) {
|
|
formatValue(sink, array[0 .. used], fmt);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Helper to avoid GC
|
|
private T[n] s(T, size_t n)(auto ref T[n] array) pure nothrow @nogc @safe {
|
|
return array;
|
|
}
|
|
|
|
@nogc nothrow unittest {
|
|
Vector!int vec;
|
|
assert(vec.empty);
|
|
vec.add(0);
|
|
vec.add(1);
|
|
vec.add(2);
|
|
vec.add(3);
|
|
vec.add(4);
|
|
vec.add(5);
|
|
assert(vec.length == 6);
|
|
assert(vec[3] == 3);
|
|
assert(vec[5] == 5);
|
|
assert(vec[] == [0, 1, 2, 3, 4, 5].s);
|
|
assert(!vec.empty);
|
|
vec.remove(3);
|
|
assert(vec.length == 5);
|
|
assert(vec[] == [0, 1, 2, 5, 4].s); //unstable remove
|
|
}
|
|
|
|
@nogc nothrow unittest {
|
|
Vector!int vec;
|
|
assert(vec.empty);
|
|
vec ~= [0, 1, 2, 3, 4, 5].s;
|
|
assert(vec[] == [0, 1, 2, 3, 4, 5].s);
|
|
assert(vec.length == 6);
|
|
vec ~= 6;
|
|
assert(vec[] == [0, 1, 2, 3, 4, 5, 6].s);
|
|
|
|
}
|
|
|
|
@nogc nothrow unittest {
|
|
Vector!int vec;
|
|
vec ~= [0, 1, 2, 3, 4, 5].s;
|
|
vec[3] = 33;
|
|
assert(vec[3] == 33);
|
|
}
|
|
|
|
@nogc nothrow unittest {
|
|
Vector!char vec;
|
|
vec ~= "abcd";
|
|
assert(vec[] == cast(char[]) "abcd");
|
|
}
|
|
|
|
@nogc nothrow unittest {
|
|
Vector!int vec;
|
|
vec ~= [0, 1, 2, 3, 4, 5].s;
|
|
vec.length = 2;
|
|
assert(vec[] == [0, 1].s);
|
|
}
|
|
///////////////////////////////////////////
|
|
|
|
enum string checkVectorAllocations = `
|
|
//assert(gVectorsCreated==gVectorsDestroyed);
|
|
gVectorsCreated=gVectorsDestroyed=0;
|
|
scope(exit){if(gVectorsCreated!=gVectorsDestroyed){
|
|
import std.stdio : writefln;
|
|
writefln("created==destroyed %s==%s", gVectorsCreated, gVectorsDestroyed);
|
|
assert(gVectorsCreated==gVectorsDestroyed, "Vector memory leak");
|
|
}}
|
|
`;
|
|
|
|
unittest {
|
|
mixin(checkVectorAllocations);
|
|
Vector!int vecA = Vector!int([0, 1, 2, 3, 4, 5].s);
|
|
assert(vecA[] == [0, 1, 2, 3, 4, 5].s);
|
|
Vector!int vecB;
|
|
vecB = vecA;
|
|
assert(vecB[] == [0, 1, 2, 3, 4, 5].s);
|
|
assert(vecB.array.ptr != vecA.array.ptr);
|
|
assert(vecB.used == vecA.used);
|
|
Vector!int vecC = vecA;
|
|
assert(vecC[] == [0, 1, 2, 3, 4, 5].s);
|
|
assert(vecC.array.ptr != vecA.array.ptr);
|
|
assert(vecC.used == vecA.used);
|
|
Vector!int vecD = vecA.init;
|
|
}
|
|
|
|
unittest {
|
|
static int numInit = 0;
|
|
static int numDestroy = 0;
|
|
scope (exit) {
|
|
assert(numInit == numDestroy);
|
|
}
|
|
static struct CheckDestructor {
|
|
int num = 1;
|
|
|
|
this(this) {
|
|
numInit++;
|
|
}
|
|
|
|
this(int n) {
|
|
num = n;
|
|
numInit++;
|
|
|
|
}
|
|
|
|
~this() {
|
|
numDestroy++;
|
|
}
|
|
}
|
|
|
|
CheckDestructor[2] arr = [CheckDestructor(1), CheckDestructor(1)];
|
|
Vector!CheckDestructor vec;
|
|
vec ~= CheckDestructor(1);
|
|
vec ~= arr;
|
|
vec.remove(1);
|
|
}
|
|
|
|
unittest {
|
|
assert(gVectorsCreated == gVectorsDestroyed);
|
|
gVectorsCreated = 0;
|
|
gVectorsDestroyed = 0;
|
|
scope (exit) {
|
|
assert(gVectorsCreated == gVectorsDestroyed);
|
|
}
|
|
string strA = "aaa bbb";
|
|
string strB = "ccc";
|
|
Vector!(Vector!char) vecA = Vector!(Vector!char)(Vector!char(cast(char[]) strA));
|
|
assert(vecA[0] == Vector!char(cast(char[]) strA));
|
|
Vector!(Vector!char) vecB;
|
|
vecB = vecA;
|
|
assert(vecB[0] == Vector!char(cast(char[]) strA));
|
|
assert(vecA.array.ptr != vecB.array.ptr);
|
|
assert(vecB.used == vecA.used);
|
|
assert(vecB[0].array.ptr != vecA[0].array.ptr);
|
|
assert(vecB[0].used == vecA[0].used);
|
|
}
|
|
|
|
unittest {
|
|
static struct Test {
|
|
int num;
|
|
@disable this(this);
|
|
}
|
|
|
|
Vector!Test test;
|
|
}
|