mirror of https://gitlab.com/basile.b/dexed.git
dexed-d, remove unused stuff added after copy of iz.memory
This commit is contained in:
Basile Burg
parent
5b59cf30a4
commit
e9bcb9b6ac
464
dexed-d/src/iz.d
464
dexed-d/src/iz.d
|
|
@ -274,92 +274,6 @@ package template hasManagedDimension(T)
|
||||||
enum hasManagedDimension = false;
|
enum hasManagedDimension = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
alias A0 = int[];
|
|
||||||
static assert(hasManagedDimension!A0);
|
|
||||||
alias A1 = int[2][];
|
|
||||||
static assert(hasManagedDimension!A1);
|
|
||||||
alias A2 = int[][2];
|
|
||||||
static assert(hasManagedDimension!A2);
|
|
||||||
alias A3 = int[3][2];
|
|
||||||
static assert(!hasManagedDimension!A3);
|
|
||||||
alias A4 = int[][3][2];
|
|
||||||
static assert(hasManagedDimension!A4);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
class Foo{int[][2][4] a;}
|
|
||||||
static assert(MustAddGcRange!Foo);
|
|
||||||
class Bar{@NoGc int[][2][4] a;}
|
|
||||||
static assert(!MustAddGcRange!Bar);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* When mixed in a aggregate this template has for effect to disable the usage
|
|
||||||
* the $(D new) operator.
|
|
||||||
*/
|
|
||||||
mixin template disableNew()
|
|
||||||
{
|
|
||||||
@disable new();
|
|
||||||
}
|
|
||||||
///
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
// class requiring users to use allocators.
|
|
||||||
class NotUsableWithNew
|
|
||||||
{
|
|
||||||
mixin disableNew;
|
|
||||||
}
|
|
||||||
|
|
||||||
// statically verify that `new` cannot be used.
|
|
||||||
static assert(!__traits(compiles, new NotUsableWithNew));
|
|
||||||
|
|
||||||
// Ok with a custom allocator
|
|
||||||
auto a = construct!NotUsableWithNew();
|
|
||||||
destruct(a);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* When mixed in class this template has for effect to automatically call the
|
|
||||||
* nearest inherited destructor if no destructor is present, otherwise a call
|
|
||||||
* to $(D callInheritedDtor()) should be made in the last LOC of the destructor.
|
|
||||||
*/
|
|
||||||
mixin template inheritedDtor()
|
|
||||||
{
|
|
||||||
|
|
||||||
static assert(is(typeof(this) == class));
|
|
||||||
|
|
||||||
private
|
|
||||||
{
|
|
||||||
import std.traits: BaseClassesTuple;
|
|
||||||
|
|
||||||
alias __iz_B = BaseClassesTuple!(typeof(this));
|
|
||||||
enum hasDtor = __traits(hasMember, typeof(this), "__dtor");
|
|
||||||
static if (hasDtor && !__traits(isSame, __traits(parent, typeof(this).__dtor), typeof(this)))
|
|
||||||
enum inDtor = true;
|
|
||||||
else
|
|
||||||
enum inDtor = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
public void callInheritedDtor(classT = typeof(this))()
|
|
||||||
{
|
|
||||||
import std.meta: aliasSeqOf;
|
|
||||||
import std.range: iota;
|
|
||||||
|
|
||||||
foreach(i; aliasSeqOf!(iota(0, __iz_B.length)))
|
|
||||||
static if (__traits(hasMember, __iz_B[i], "__xdtor"))
|
|
||||||
{
|
|
||||||
mixin("this." ~ __iz_B[i].stringof ~ ".__xdtor;");
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static if (!hasDtor || inDtor)
|
|
||||||
public ~this() {callInheritedDtor();}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Returns a new, GC-free, class instance.
|
* Returns a new, GC-free, class instance.
|
||||||
*
|
*
|
||||||
|
|
@ -384,33 +298,6 @@ if (is(CT == class) && !isAbstractClass!CT)
|
||||||
return cast(CT) memory;
|
return cast(CT) memory;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a new, GC-free, class instance.
|
|
||||||
*
|
|
||||||
* This overload is designed to create factories and like the default
|
|
||||||
* Object.factory method, it only calls, if possible, the default constructor.
|
|
||||||
* The factory() function implemented in this iz.memory is based on this
|
|
||||||
* construct() overload.
|
|
||||||
*
|
|
||||||
* Params:
|
|
||||||
* tic = The TypeInfo_Class of the Object to create.
|
|
||||||
*/
|
|
||||||
Object construct(TypeInfo_Class tic) @trusted
|
|
||||||
{
|
|
||||||
if (tic.m_flags & 64)
|
|
||||||
return null;
|
|
||||||
auto size = tic.initializer.length;
|
|
||||||
auto memory = getMem(size);
|
|
||||||
memory[0 .. size] = tic.initializer[];
|
|
||||||
Object result = cast(Object) memory;
|
|
||||||
if (tic.defaultConstructor)
|
|
||||||
tic.defaultConstructor(result);
|
|
||||||
import core.memory: GC;
|
|
||||||
GC.addRange(memory, size, tic);
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Returns a new, GC-free, pointer to a struct or to an union.
|
* Returns a new, GC-free, pointer to a struct or to an union.
|
||||||
*
|
*
|
||||||
|
|
@ -610,357 +497,6 @@ if (isBasicType!T)
|
||||||
instance = null;
|
instance = null;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a pointer to a new, GC-free, basic variable.
|
|
||||||
* Any variable allocated using this function must be manually freed with freeMem.
|
|
||||||
*
|
|
||||||
* Params:
|
|
||||||
* T = The type of the pointer to return.
|
|
||||||
* preFill = Optional, boolean indicating if the result has to be initialized.
|
|
||||||
* a = Optional, the value.
|
|
||||||
*/
|
|
||||||
T* newPtr(T, bool preFill = false, A...)(A a)
|
|
||||||
if (isBasicType!T && A.length <= 1)
|
|
||||||
{
|
|
||||||
T* result = cast(T*) getMem(T.sizeof);
|
|
||||||
static if (A.length == 1)
|
|
||||||
*result = a[0];
|
|
||||||
else static if (preFill)
|
|
||||||
*result = T.init;
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Frees and invalidates a list of classes instances or struct pointers.
|
|
||||||
* $(D destruct()) is called for each item.
|
|
||||||
*
|
|
||||||
* Params:
|
|
||||||
* objs = Variadic list of Object instances.
|
|
||||||
*/
|
|
||||||
void destructEach(Objs...)(auto ref Objs objs)
|
|
||||||
if (Objs.length > 1)
|
|
||||||
{
|
|
||||||
foreach(ref obj; objs)
|
|
||||||
destruct(obj);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Register a class type that can be created dynamically, using its name.
|
|
||||||
*
|
|
||||||
* Class registration should only be done in module constructors. This allow
|
|
||||||
* the registration to be thread safe since module constructors are executed
|
|
||||||
* in the main thread.
|
|
||||||
*
|
|
||||||
* Params:
|
|
||||||
* T = A class.
|
|
||||||
* name = The name used to register the class.
|
|
||||||
* By default the $(D T.stringof) is used.
|
|
||||||
* f = The class repository, a hashmap of TypeInfo_Class by string.
|
|
||||||
*/
|
|
||||||
void registerFactoryClass(T, F)(ref F f, string name = "")
|
|
||||||
if (is(T == class) && !isAbstractClass!T)
|
|
||||||
{
|
|
||||||
if (!name.length)
|
|
||||||
name = T.stringof;
|
|
||||||
f[name] = typeid(T);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Calls registerClass() for each template argument.
|
|
||||||
*
|
|
||||||
* Params:
|
|
||||||
* A = A list of classes, from one up to nine.
|
|
||||||
* f = The class repository, a hashmap of TypeInfo_Class by string.
|
|
||||||
*/
|
|
||||||
void registerFactoryClasses(A1, A2 = void, A3 = void, A4 = void, A5 = void,
|
|
||||||
A6 = void, A7 = void, A8 = void, A9 = void, F)(ref F f)
|
|
||||||
{
|
|
||||||
void tryRegister(A)()
|
|
||||||
{
|
|
||||||
static if (is(A == class))
|
|
||||||
registerFactoryClass!(A, F)(f);
|
|
||||||
else static if (!is(A == void))
|
|
||||||
static assert(0, A.stringof ~ " is not a class");
|
|
||||||
}
|
|
||||||
tryRegister!A1;tryRegister!A2;tryRegister!A3;
|
|
||||||
tryRegister!A4;tryRegister!A5;tryRegister!A6;
|
|
||||||
tryRegister!A7;tryRegister!A8;tryRegister!A9;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Constructs a class instance using a gc-free factory.
|
|
||||||
* The usage is similar to Object.factory() except that by default
|
|
||||||
* registered classes don't take the module in account.
|
|
||||||
*
|
|
||||||
* Params:
|
|
||||||
* className = the class name, as registered in registerFactoryClass().
|
|
||||||
* factory = The class repository, a hashmap of TypeInfo_Class by string.
|
|
||||||
* Throws:
|
|
||||||
* An Exception if the class is not registered.
|
|
||||||
*/
|
|
||||||
Object factory(F)(ref F f, string className)
|
|
||||||
{
|
|
||||||
TypeInfo_Class* tic = className in f;
|
|
||||||
if (!tic)
|
|
||||||
throw construct!Exception("factory exception, unregistered class");
|
|
||||||
return
|
|
||||||
construct(*tic);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
import core.memory: GC;
|
|
||||||
|
|
||||||
interface I{}
|
|
||||||
class AI: I{}
|
|
||||||
|
|
||||||
auto a = construct!Object;
|
|
||||||
a.destruct;
|
|
||||||
assert(!a);
|
|
||||||
a.destruct;
|
|
||||||
assert(!a);
|
|
||||||
a.destruct;
|
|
||||||
|
|
||||||
auto b = construct!Object;
|
|
||||||
auto c = construct!Object;
|
|
||||||
destructEach(a,b,c);
|
|
||||||
assert(!a);
|
|
||||||
assert(!b);
|
|
||||||
assert(!c);
|
|
||||||
destructEach(a,b,c);
|
|
||||||
assert(!a);
|
|
||||||
assert(!b);
|
|
||||||
assert(!c);
|
|
||||||
|
|
||||||
Object foo = construct!Object;
|
|
||||||
Object bar = new Object;
|
|
||||||
assert( GC.addrOf(cast(void*)foo) == null );
|
|
||||||
assert( GC.addrOf(cast(void*)bar) != null );
|
|
||||||
foo.destruct;
|
|
||||||
bar.destroy;
|
|
||||||
|
|
||||||
struct Foo
|
|
||||||
{
|
|
||||||
this(size_t a,size_t b,size_t c)
|
|
||||||
{
|
|
||||||
this.a = a;
|
|
||||||
this.b = b;
|
|
||||||
this.c = c;
|
|
||||||
}
|
|
||||||
size_t a,b,c;
|
|
||||||
}
|
|
||||||
|
|
||||||
Foo * foos = construct!Foo(1,2,3);
|
|
||||||
Foo * bars = new Foo(4,5,6);
|
|
||||||
assert(foos.a == 1);
|
|
||||||
assert(foos.b == 2);
|
|
||||||
assert(foos.c == 3);
|
|
||||||
assert( GC.addrOf(cast(void*)foos) == null );
|
|
||||||
assert( GC.addrOf(cast(void*)bars) != null );
|
|
||||||
foos.destruct;
|
|
||||||
bars.destroy;
|
|
||||||
assert(!foos);
|
|
||||||
foos.destruct;
|
|
||||||
assert(!foos);
|
|
||||||
|
|
||||||
union Uni{bool b; ulong ul;}
|
|
||||||
Uni* uni0 = construct!Uni();
|
|
||||||
Uni* uni1 = new Uni();
|
|
||||||
assert( GC.addrOf(cast(void*)uni0) == null );
|
|
||||||
assert( GC.addrOf(cast(void*)uni1) != null );
|
|
||||||
uni0.destruct;
|
|
||||||
assert(!uni0);
|
|
||||||
uni0.destruct;
|
|
||||||
assert(!uni0);
|
|
||||||
|
|
||||||
auto ai = construct!AI;
|
|
||||||
auto i = cast(I) ai;
|
|
||||||
destruct(i);
|
|
||||||
assert(i is null);
|
|
||||||
|
|
||||||
abstract class Abst {}
|
|
||||||
Object ab = construct(typeid(Abst));
|
|
||||||
assert(ab is null);
|
|
||||||
}
|
|
||||||
|
|
||||||
@nogc unittest
|
|
||||||
{
|
|
||||||
class Foo {@nogc this(int a){} @nogc~this(){}}
|
|
||||||
Foo foo = construct!Foo(0);
|
|
||||||
destruct(foo);
|
|
||||||
assert(foo is null);
|
|
||||||
|
|
||||||
static struct Bar {}
|
|
||||||
Bar* bar = construct!Bar;
|
|
||||||
destruct(bar);
|
|
||||||
assert(bar is null);
|
|
||||||
|
|
||||||
static struct Baz {int i; this(int,int) @nogc {}}
|
|
||||||
Baz* baz = construct!Baz(0,0);
|
|
||||||
destruct(baz);
|
|
||||||
assert(baz is null);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
struct Foo {int a; ulong b;}
|
|
||||||
Foo* f = construct!Foo(1,2);
|
|
||||||
assert(f.a == 1);
|
|
||||||
assert(f.b == 2);
|
|
||||||
destruct(f);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
import core.memory: GC;
|
|
||||||
import std.math: isNaN;
|
|
||||||
|
|
||||||
auto f = newPtr!(float,true);
|
|
||||||
assert(isNaN(*f));
|
|
||||||
auto ui = newPtr!int;
|
|
||||||
auto i = newPtr!uint;
|
|
||||||
auto l = new ulong;
|
|
||||||
auto u = newPtr!uint(8);
|
|
||||||
assert(*u == 8u);
|
|
||||||
|
|
||||||
assert(ui);
|
|
||||||
assert(i);
|
|
||||||
assert(f);
|
|
||||||
|
|
||||||
assert(GC.addrOf(f) == null);
|
|
||||||
assert(GC.addrOf(i) == null);
|
|
||||||
assert(GC.addrOf(ui) == null);
|
|
||||||
assert(GC.addrOf(l) != null);
|
|
||||||
assert(GC.addrOf(u) == null);
|
|
||||||
|
|
||||||
*i = 8u;
|
|
||||||
assert(*i == 8u);
|
|
||||||
|
|
||||||
freeMem(ui);
|
|
||||||
freeMem(i);
|
|
||||||
freeMem(f);
|
|
||||||
freeMem(u);
|
|
||||||
|
|
||||||
assert(ui == null);
|
|
||||||
assert(i == null);
|
|
||||||
assert(f == null);
|
|
||||||
|
|
||||||
auto ptr = getMem(16);
|
|
||||||
assert(ptr);
|
|
||||||
assert(GC.addrOf(ptr) == null);
|
|
||||||
ptr.freeMem;
|
|
||||||
assert(!ptr);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
class A{string text; this(){text = "A";}}
|
|
||||||
class B{string text; this(){text = "B";}}
|
|
||||||
class C{int[] array; this(){array = [1,2,3];}}
|
|
||||||
enum TypeInfo_Class[3] tics = [typeid(A),typeid(B),typeid(C)];
|
|
||||||
|
|
||||||
A a = cast(A) construct(tics[0]);
|
|
||||||
assert(a.text == "A");
|
|
||||||
B b = cast(B) construct(tics[1]);
|
|
||||||
assert(b.text == "B");
|
|
||||||
C c = cast(C) construct(tics[2]);
|
|
||||||
assert(c.array == [1,2,3]);
|
|
||||||
|
|
||||||
destructEach(a, b, c);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
alias Factory = TypeInfo_Class[string];
|
|
||||||
__gshared Factory classRegistry;
|
|
||||||
|
|
||||||
class A{string text; this(){text = "A";}}
|
|
||||||
class B{string text; this(){text = "B";}}
|
|
||||||
class C{int[] array; this(){array = [1,2,3];}}
|
|
||||||
registerFactoryClass!A(classRegistry);
|
|
||||||
classRegistry.registerFactoryClass!B;
|
|
||||||
classRegistry.registerFactoryClass!C;
|
|
||||||
|
|
||||||
registerFactoryClasses!(A,B)(classRegistry);
|
|
||||||
|
|
||||||
A a = cast(A) classRegistry.factory("A");
|
|
||||||
assert(a.text == "A");
|
|
||||||
B b = cast(B) classRegistry.factory("B");
|
|
||||||
assert(b.text == "B");
|
|
||||||
C c = cast(C) classRegistry.factory("C");
|
|
||||||
assert(c.array == [1,2,3]);
|
|
||||||
|
|
||||||
version(checkleaks) {} else
|
|
||||||
{
|
|
||||||
import std.exception: assertThrown;
|
|
||||||
assertThrown(classRegistry.factory("D"));
|
|
||||||
}
|
|
||||||
|
|
||||||
destructEach(a,b,c);
|
|
||||||
}
|
|
||||||
|
|
||||||
@nogc unittest
|
|
||||||
{
|
|
||||||
void* src = getMem(32);
|
|
||||||
void* dst = getMem(32);
|
|
||||||
(cast (ubyte*)src)[0..32] = 8;
|
|
||||||
copyMem(dst, src, 32);
|
|
||||||
foreach(immutable i; 0 .. 32)
|
|
||||||
assert((cast (ubyte*)src)[i] == (cast (ubyte*)dst)[i]);
|
|
||||||
(cast (ubyte*)src)[0..32] = 7;
|
|
||||||
src = reallocMem(src, 32 + 16);
|
|
||||||
ubyte* ovl = (cast (ubyte*)src) + 16;
|
|
||||||
moveMem(cast(void*)ovl, cast(void*)src, 32);
|
|
||||||
assert((cast (ubyte*)ovl)[31] == 7);
|
|
||||||
freeMem(src);
|
|
||||||
freeMem(dst);
|
|
||||||
}
|
|
||||||
|
|
||||||
@nogc unittest
|
|
||||||
{
|
|
||||||
@NoInit static struct Foo {uint a = 1; ~this() @nogc{}}
|
|
||||||
Foo* foo = construct!Foo;
|
|
||||||
assert(foo.a != 1);
|
|
||||||
@NoInit static class Bar {uint a = 1; ~this() @nogc{}}
|
|
||||||
Bar bar = construct!Bar;
|
|
||||||
assert(bar.a != 1);
|
|
||||||
destructEach(foo, bar);
|
|
||||||
}
|
|
||||||
|
|
||||||
unittest
|
|
||||||
{
|
|
||||||
static int i;
|
|
||||||
|
|
||||||
template impl()
|
|
||||||
{
|
|
||||||
~this(){i += 1;}
|
|
||||||
}
|
|
||||||
|
|
||||||
static class Base
|
|
||||||
{
|
|
||||||
mixin impl;
|
|
||||||
mixin inheritedDtor;
|
|
||||||
~this(){i += 2;}
|
|
||||||
}
|
|
||||||
|
|
||||||
static class Derived: Base
|
|
||||||
{
|
|
||||||
mixin inheritedDtor;
|
|
||||||
~this(){i += 3; callInheritedDtor;}
|
|
||||||
}
|
|
||||||
|
|
||||||
Base b = construct!Derived;
|
|
||||||
// without static type
|
|
||||||
destruct(cast(Object) b);
|
|
||||||
assert(i == 6);
|
|
||||||
i = 0;
|
|
||||||
|
|
||||||
Derived d = construct!Derived;
|
|
||||||
// with static type
|
|
||||||
destruct(d);
|
|
||||||
assert(i == 6);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Generic, manually managed, array.
|
* Generic, manually managed, array.
|
||||||
*
|
*
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue