/**

C++-style automatic memory management smart pointers for D using `std.experimental.allocator`.

Unlike the C++ variants, the smart pointers themselves allocate the memory for the objects they contain.

That ensures the right allocator is used to dispose of the memory as well.

Allocators are template arguments instead of using `theAllocator` so

that these smart pointers can be used in `@nogc` code. However, they

will default to `typeof(theAllocator)` for simplicity.

Another reason to have to pass in the type of allocator is to decide how it is to

be stored. Stateless allocators can be "stored" by value and imply zero-cost `Unique` pointers.

Singleton allocators such as Mallocator (that have an `instance` attribute/member function)

don't need to be passed in to the constructor. This is detected at compile-time as an example

of design by instrospection.

`RefCounted` leverages D's type system by doing atomic reference counting *iff* the type of the contained

object is `shared`. Otherwise it's non-atomic.

*/

module automem;

public import automem.unique;

public import automem.ref_counted;

public import automem.vector;

public import automem.array;

@safe unittest {

    import std.algorithm: move;

    static struct Point {

        int x;

        int y;

    }

    // set theAllocator as desired beforehand, e.g.

    // theAllocator = allocatorObject(Mallocator.instance)

    {

        // must pass arguments to initialise the contained object

        // auto u2 = u1; // won't compile, can only move

    }

    // memory freed for the Point structure created in the block

    {

        {

        } // ref count goes to 1 here

    } // ref count goes to 0 here, memory released

    {

        import std.algorithm: map, equal;

        import std.range: iota;

        // `vector` is also known as `array`

        // reallocations are @system since old pointers can dangle

        }();

    } // memory for the array released here

}

// @nogc test - must explicitly use the allocator for compile-time guarantees

@safe @nogc unittest {

    import std.experimental.allocator.mallocator: Mallocator;

    static struct Point {

        int x;

        int y;

    }

    {

        // must pass arguments to initialise the contained object

    }

    // memory freed for the Point structure created in the block

    // similarly for the other types

}