core.lifetime

Undocumented in source.

Members

Functions

_d_newThrowable
T _d_newThrowable()

Allocate an exception of type T from the exception pool. T must be Throwable or derived from it and cannot be a COM or C++ class.

_d_newclassT
T _d_newclassT()

Create a new class instance. Allocates memory and sets fields to their initial value, but does not call a constructor.

_d_newclassTTrace
T _d_newclassTTrace(string file, int line, string funcname)

TraceGC wrapper around core.lifetime._d_newclassT.

_d_newitemT
T* _d_newitemT()

Allocate an initialized non-array item.

_d_newitemTTrace
T* _d_newitemTTrace(string file, int line, string funcname)

TraceGC wrapper around core.lifetime._d_newitemT.

copyEmplace
void copyEmplace(S source, T target)

Emplaces a copy of the specified source value into uninitialized memory, i.e., simulates T target = source copy-construction for cases where the target memory is already allocated and to be initialized with a copy.

emplace
T* emplace(T* chunk)

Given a pointer chunk to uninitialized memory (but already typed as T), constructs an object of non-class type T at that address. If T is a class, initializes the class reference to null.

emplace
T* emplace(T* chunk, Args args)

Given a pointer chunk to uninitialized memory (but already typed as a non-class type T), constructs an object of type T at that address from arguments args. If T is a class, initializes the class reference to args[0]. This function can be @trusted if the corresponding constructor of T is @safe.

emplace
T emplace(T chunk, Args args)

Given a raw memory area chunk (but already typed as a class type T), constructs an object of class type T at that address. The constructor is passed the arguments Args. If T is an inner class whose outer field can be used to access an instance of the enclosing class, then Args must not be empty, and the first member of it must be a valid initializer for that outer field. Correct initialization of this field is essential to access members of the outer class inside T methods. Note: This function is @safe if the corresponding constructor of T is @safe.

emplace
T emplace(void[] chunk, Args args)

Given a raw memory area chunk, constructs an object of class type T at that address. The constructor is passed the arguments Args. If T is an inner class whose outer field can be used to access an instance of the enclosing class, then Args must not be empty, and the first member of it must be a valid initializer for that outer field. Correct initialization of this field is essential to access members of the outer class inside T methods. Preconditions: chunk must be at least as large as T needs and should have an alignment multiple of T's alignment. (The size of a class instance is obtained by using __traits(classInstanceSize, T)). Note: This function can be @trusted if the corresponding constructor of T is @safe.

emplace
T* emplace(void[] chunk, Args args)

Given a raw memory area chunk, constructs an object of non-class type T at that address. The constructor is passed the arguments args, if any. Preconditions: chunk must be at least as large as T needs and should have an alignment multiple of T's alignment. Note: This function can be @trusted if the corresponding constructor of T is @safe.

move
void move(T source, T target)
T move(T source)

Moves source into target, via a destructive copy when necessary.

moveEmplace
void moveEmplace(T source, T target)

Similar to move but assumes target is uninitialized. This is more efficient because source can be blitted over target without destroying or initializing it first.

Structs

S1
struct S1
Undocumented in source.
S2
struct S2
Undocumented in source.
S3
struct S3
Undocumented in source.
S4
struct S4
Undocumented in source.

Templates

TypeInfoSize
template TypeInfoSize(T)
Undocumented in source.
_d_delstructImpl
template _d_delstructImpl(T)

Implementation of _d_delstruct and _d_delstructTrace

forward
template forward(args...)

Forwards function arguments while keeping out, ref, and lazy on the parameters.

Meta