atilaneves / automem Goto Github PK

/+dub.sdl:
dependency "automem" version="~>0.6.4"
+/
import automem.ref_counted;
import std.range;
import std.stdio;

int created, destroyed;

void main() {
    {
        RefCounted!S s = RefCounted!S(1);
        auto r1 = repeat(s, 2);
        auto r2 = repeat(s, 2);
        foreach(s1, s2; lockstep(r1, r2))
            assert(s1.val == s2.val);
    }
    writeln("after lockstep: created ", created, " vs destroyed ", destroyed);
    assert(created == 1);
    assert(destroyed == 1);
    {
        RefCounted!S s = RefCounted!S(1);
        auto r1 = repeat(s, 2);
        auto r2 = repeat(s, 2);
        foreach(s1, s2; zip(r1, r2))
            assert(s1.val == s2.val);
    }
    writeln("after zip: created ", created, " vs destroyed ", destroyed);
    assert(created == 2);
    assert(destroyed == 2); // fails!
}

struct S {
    @disable this();
    @disable this(this);
    this(int val) {
        this.val = val;
        created++;
    }
    ~this() {
        destroyed++;
    }
    int val;
}

/+ dub.sdl:
dependency "automem" version="~>0.5.1"
dflags "-dip1000" "-dip25"
+/

void main() @safe
{
    import std.stdio : writefln;
    import std.experimental.allocator.mallocator: Mallocator;
    import automem.vector;

    auto vec1 = vector(1, 2, 3);
    int[] slice1 = vec1[];
    vec1.reserve(4096);
    int[] slice2 = vec1[];

    "slice1.ptr: %x, slice2.ptr: %x \nslice1: %s, slice2: %s"
        .writefln(&slice1[0], &slice2[0], slice1, slice2);
}

/+dub.sdl:
dependency "automem" version="~>0.6.1"
+/
import automem;

void main() @nogc
{
    StringM str;
}

import automem;

class Foo
{
    this() @nogc
    {
    }

    ~this() @nogc
    {
    }
}

void main() @nogc
{
    auto x = Unique!Foo();
}

import std.experimental.allocator.mallocator;
UniqueArray!(int, Mallocator) a;
a ~= [0,1];

    void release() {
		/*
		...
		*/

        dec;
        if(_impl._count == 0) {
			/*
			...
			*/
        }
    }

/+dub.sdl:
dependency "automem" version="~>0.6.1"
+/
import automem;

StringM str;

void main() @nogc
{
	str ~= "a";
	str.popBack;
	str ~= "a"; // generates the error "Assigning to non default initialised non mutable member" in vector.d:297

	assert(str.length == 1);
	assert(str[0] == 'a');
}

struct Vector(E, Allocator = typeof(theAllocator)) if(isAllocator!Allocator) {
...
    E[] _elements;
...
    /// Access the ith element. Can throw RangeError.
    ref inout(E) opIndex(long i) scope return inout {
        if(i < 0 || i >= length)
            mixin(throwBoundsException);
        return _elements[i.toSizeT];
    }
...

/+ dub.sdl:
dependency "automem" version="==0.6.0"
dflags "-preview=dip1000" "-preview=dip25"
+/

import automem.vector;

@safe:

typeof(vector(1).range()) global;

void main()
{
    auto vec1 = vector(1, 2, 3);
    global = vec1.range; // compiles, but it shouldn't
}

/+ dub.sdl:
dependency "automem" version="==0.6.0"
dflags "-preview=dip1000" "-preview=dip25"
+/

import std.stdio : writeln;
import automem.vector;

@safe:

typeof(vector(1).range()) global;

void main()
{
    escape;
    global.length.writeln; // 0
    stackSmash;
    global.length.writeln; // 42
}

void escape()
{
    auto vec1 = vector(1, 2, 3);
    global = vec1.range;
}

void stackSmash()
{
    long[4096] arr = 42;
}

/+ dub.sdl:
       dependency "automem" version="~>0.6.1"
 +/
import automem;

void main()
{
    auto r = S();
    auto rc = RefCounted!S();
    auto un = Unique!S();
    foreach(i; r) {} //works
    foreach(i; rc) {}
    foreach(i; un) {}
}

struct S
{
    @property int front() {return 0;}
    void popFront(){}
    @property bool empty(){return false;}
}

/+ dub.sdl:
       dependency "automem" version="~>0.6.1"
 +/

import automem;

void main()
{
    auto rc = RefCounted!S();
    for (auto r2 = rc; !r2.empty; r2.popFront)
    {
    }
}

struct S
{
    int front = 0;
    void popFront(){front++;}
    @property bool empty(){return front > 100;}
}