object

Переместиться к: factory · opCmp · opEquals · toHash · toString

class Object;

Все классы объектов D наследуются от Object.

string toString();

Преобразует Object в удобочитаемую человеком строку.

nothrow @trusted size_t toHash();

Вычисляет хеш-функцию для Object.

int opCmp(Object obj);

Сравнивает с другим объектом obj.

Возвращает:

this < obj	< 0
this == obj	0
this > obj	> 0

bool opEquals(Object o);

Проверить, является ли this равным o. Реализация по умолчанию сравнивает только по идентичности (используется оператор is). Обычно, переопределение для opEquals должно пытаться сравнивать объекты по их содержанию.

static Object factory(string classname);

Создать экземпляр класса, заданного полностью квалифицированным именем classname. Класс должен либо не иметь никаких конструкторов, либо иметь конструктор по умолчанию.

Возвращает:

null, если не удалось

Пример:

module foo.bar;

class C
{
    this() { x = 10; }
    int x;
}

void main()
{
    auto c = cast(C)Object.factory("foo.bar.C");
    assert(c !is null && c.x == 10);
}

auto opEquals(const Object lhs, const Object rhs);

Возвращает true, если lhs и rhs равны.

Переместиться к: classinfo · offset

struct Interface;

Информация об интерфейсе. Когда объект доступен через интерфейс, Interface* появляется как первая запись в его vtbl.

TypeInfo_Class classinfo;

.classinfo для этого интерфейса (не для содержащего класса)

size_t offset;

смещение до 'this' интерфейса от 'this' объекта

Переместиться к: offset · ti

struct OffsetTypeInfo;

Массив пар, дающих смещение и информацию о типе для каждого элемента в агрегате.

size_t offset;

Смещение члена от начала объекта

TypeInfo ti;

TypeInfo для этого члена

Переместиться к: argTypes · compare · destroy · equals · flags · getHash · init · initializer · next · offTi · postblit · rtInfo · swap · talign · tsize

abstract class TypeInfo;

Информация времени выполнения о типе. Может быть получена для любого типа, с использованием выражения Typeid.

const nothrow @trusted size_t getHash(in void* p);

Вычисляет хэш экземпляра типа.

Параметры:

void* p

указатель на начало экземпляра типа

Возвращает:

хэш

Недостатки:

fix https://issues.dlang.org/show_bug.cgi?id=12516 e.g. by changing this to a truly safe interface.

const bool equals(in void* p1, in void* p2);

Сравнивает два экземпляра на равенство.

const int compare(in void* p1, in void* p2);

Сравнивает два экземпляра на <, ==, или >.

const pure nothrow @nogc @property @safe size_t tsize();

Вычисляет размер типа.

const void swap(void* p1, void* p2);

Меняет два экземпляра типа.

inout pure nothrow @nogc @property inout(TypeInfo) next();

Get TypeInfo for 'next' type, as defined by what kind of type this is, null if none.

Я, к сожалению, не смог перевести это предложение и так и не понял из него, когда этот "следующий" тип не равен null. После некоторого исследования у меня выяснилось, что для массивов метод next() возвращает тип элемента, для ассоциативных массивов — тип значения, для всех остальных типов, проверенных мной, возвращалось null — прим. пер.

abstract const pure nothrow @nogc @safe const(void)[] initializer();

Возвращает встроенный инциализатор. If the type should be initialized to all zeros, an array with a null ptr and a length equal to the type size will be returned. Для статического массива будет возвращён встроенный инциализатор для единственного элемента массива, используйте tsize, чтобы получить правильный размер.

deprecated alias init = initializer;

Scheduled for deprecation. Пожалуйста, используйте вместо этого initializer.

const pure nothrow @nogc @property @safe uint flags();

Получить флаги для типа: 1 означает, что сборщик мусора должен сканировать указатели, 2 означает, что аргументы этого типа переданы в регистр XMM

const const(OffsetTypeInfo)[] offTi();

Получить информацию типа о содержимом типа; null если не доступно

У меня для всех типов, которые я пробовал, offTi() возвращала пустой массив — прим. пер.

const void destroy(void* p);

Запустить деструктор для объекта и всех под-объектов

const void postblit(void* p);

Запустить postblit на объекте и всех под-объектах

Как я понял, словом postblit обозначается конструктор копирования this(this) — прим. пер.

const pure nothrow @nogc @property @safe size_t talign();

Возвращает выравнивание типа

nothrow @safe int argTypes(out TypeInfo arg1, out TypeInfo arg2);

Возвращает внутреннюю информацию на аргументы, выровненные в 8 байт. Смотрите X86-64 ABI 3.2.3

const pure nothrow @nogc @property @safe immutable(void)* rtInfo();

Возвращает информацию, используемую сборщиком мусора для выполнения аккуратного сбора.

Переместиться к: base · create · find · interfaces · m_init · name · vtbl

class TypeInfo_Class: object.TypeInfo;

Информация времени выполнения о классе. Может быть получена из экземпляра объекта, используя свойство .classinfo.

byte[] m_init;

статический инициализатор класса (init.length даёт размер класса в байтах)

string name;

имя класса

void*[] vtbl;

указатель на таблицу виртуальных методов

Interface[] interfaces;

интерфейсы, которые реализует данный класс

TypeInfo_Class base;

базовый класс

static const(TypeInfo_Class) find(in char[] classname);

Search all modules for TypeInfo_Class corresponding to classname

Ищет все модули для TypeInfo_Class, соответствующие classname.

Непонятно, что это за "соответствующие модули". Желающие разобраться могут почитать это обсуждение — прим. пер.

Возвращает:

null, если не найдено

const Object create();

Создаёт экземпляр объекта, представленного 'this'.

Переместиться к: file · info · line · msg · next · toString

class Throwable;

Базовый класс всех объектов исключений.

Все объекты бросаемых исключений должны наследоваться от Throwable. Класс Exception, являющийся производным от этого класса, представляет категорию объектов исключений, безопасных, чтобы их ловить и обрабатывать. В принципе, не следует ловить объекты Throwable, которые не являются производными от Exception, так как они представляют неисправимые ошибки времени выполнения. Определенные гарантии времени выполнения могут не выполняться, когда выбрасываются эти ошибки, делая ненадежным продолжение выполнения после их отлова.

string msg;

Сообщение, описывающее ошибку.

string file;

size_t line;

Имя файла file и номер строки line исходного кода D, соответствующие месту, откуда была брошена ошибка.

TraceInfo info;

Трассировки стека, где произошло ошибка. Это мутный объект, который либо может быть преобразован в строку, или проитерирован с foreach, для извлечения элементов в трассировке стека (в виде строк).

Throwable next;

Ссылка на следующую ошибку в списке. Это используется, когда новый Throwable брошен внутри блока catch. Первоначально пойманное исключение будет подключено к новому Throwable через это поле.

Переместиться к: 2

string toString();

Перекрывает Object.toString и возвращает сообщение об ошибке. Внутренне перенаправляет к перегруженному методу toString, который принимает делегат.

const void toString(scope void delegate(in char[]) sink);

Иерархия Throwable использует перегруженный метод toString, который принимает делегат, чтобы предотвратить распределение памяти сборщиком мусора, которые не могут быть выполнены в определенных ошибочных ситуациях. Перекройте этот метод toString, чтобы исправить по своему усмотрению сообщение об ошибке.

Переместиться к: this

class Exception: object.Throwable;

Базовый класс всех ошибок, которые считаются безопасными, чтобы их ловить и обрабатывать.

В принципе, только объекты, производные от этого класса, безопасны, чтобы их ловить в блоке catch. Бросаемые объекты, не производные от Exception , представляют ошибки времени выполнения, которые не надо ловить, поскольку определенные гарантии времени выполнения могут не выполняться, что делает небезопасным продолжение выполнения программы.

pure nothrow @nogc @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null);

Создает новый экземпляр Исключения. Параметр next используется внутренне и всегда должен быть null при передаче пользовательским кодом. Этот конструктор не бросает автоматически вновь созданное Исключение; для этой цели должно быть использовано утверждение throw.

Переместиться к: bypassedException · this

class Error: object.Throwable;

Базовый класс всех неисправимых ошибок времени выполнения.

Представляет категорию объектов Throwable, которые не являются безопасными, чтобы их ловить и обрабатывать. В принципе, не следует ловить объекты Error, так как они представляют неисправимые ошибки времени выполнения. Определенные гарантии времени выполнения может не выполняться, когда брошены эти ошибки, делая ненадежным продолжение выполнения после их отлова.

pure nothrow @nogc @safe this(string msg, Throwable next = null);

Создает новый экземпляр Error. Параметр next используется внутренне и всегда должен быть null при передаче пользовательским кодом. Этот конструктор не бросает автоматически вновь созданный Error; для этой цели должно быть использовано утверждение throw.

Throwable bypassedException;

Первое исключение Exception, во время обработки которого была брошена эта Ошибка, или null, если никакие исключения не зависли.

void destroy(T)(T obj)
if (is(T == class));

Уничтожает данный объект и устанавливает его в недействительное состояние. Это используется для уничтожения объекта таким образом, чтобы при любой очистке деструктор или финализатор не выполнялись, и чтобы он больше не ссылался на любые другие объекты. Это не инициирует цикл GC или освобождение какой-либо памяти GC.

pure nothrow @property @trusted size_t capacity(T)(T[] arr);

(Свойство) Получить текущую capacity (ёмкость) среза. capacity является размером, до которого срез можно увеличить до того, как основной массив должен будет перераспределиться или расшириться.

Если добавление должно перераспределить память среза без возможности расширения, тогда возвращается 0. Это случается, когда срез ссылается на статический массив, или если другой срез ссылается на элементы после конца текущего среза.

Замечание: capacity среза может быть уплотнена действиями с другими срезами.

Examples:

//Срез статического массива: нет ёмкости
int[4] sarray = [1, 2, 3, 4];
int[]  slice  = sarray[];
assert(sarray.capacity == 0);
//Добавление к срезу вызывает перераспределение в новый массив
slice ~= 5;
assert(slice.capacity >= 5);

//Срезы динамического массива
int[] a = [1, 2, 3, 4];
int[] b = a[1 .. $];
int[] c = a[1 .. $ - 1];
debug(SENTINEL) {} else // не нулевая ёмкость очень зависит от массива и реализации GC
{
    assert(a.capacity != 0);
    assert(a.capacity == b.capacity + 1); //a and b разделяют один и тот же хвост
}
assert(c.capacity == 0);              //добавление к c должно перераспределить c.

pure nothrow @trusted size_t reserve(T)(ref T[] arr, size_t newcapacity);

Резервирует capacity (ёмкость) для среза. capacity является размером, до которого срез можно увеличить до того, как основной массив должен будет перераспределиться или расшириться.

Возвращает значение новой ёмкости массива (которая может быть больше, чем запрошенная ёмкость).

Examples:

//Срез статического массива: нет ёмкости. 
//Резервирование вызывает перераспределение.
int[4] sarray = [1, 2, 3, 4];
int[]  slice  = sarray[];
auto u = slice.reserve(8);
assert(u >= 8);
assert(sarray.ptr !is slice.ptr);
assert(slice.capacity == u);

//Срезы динамического массива
int[] a = [1, 2, 3, 4];
a.reserve(8); //подготовить для добавления ещё 4 элементов
auto p = a.ptr;
u = a.capacity;
a ~= [5, 6, 7, 8];
assert(p == a.ptr);      //не должен был перераспределяться
assert(u == a.capacity); //не должен был расширяться

nothrow ref inout(T[]) assumeSafeAppend(T)(auto ref inout(T[]) arr);

Предположительно безопасное добавление в этот массив. Добавления, сделанные в этот массив вызовом этой функции, могут выполняться на месте, даже если массив был срезом большего массива в начале.

Используйте это только тогда, когда очевидно, что нет никаких элементов, используемых за пределами массива в блоке памяти. Если есть, эти элементы будут перезаписаны при добавлении к этому массиву.

Вызыв этой функции, и затем использование ссылок на данные, расположенные после данного массива, приведёт к неопределенному поведению.

Возвращает:

Возвращает вход

Примеры:

int[] a = [1, 2, 3, 4];

// Без assumeSafeAppend. Добавление перераспределяет память.
int[] b = a [0 .. 3];
b ~= 5;
assert(a.ptr != b.ptr);

debug(SENTINEL) {} else
{
    // С assumeSafeAppend. Добавление перезаписывает.
    int[] c = a [0 .. 3];
    c.assumeSafeAppend() ~= 5;
    assert(a.ptr == c.ptr);
    // Добавлю, что теперь a == [1, 2, 3, 5] - прим. пер.

}

bool _ArrayEq(T1, T2)(T1[] a1, T2[] a2);

Вспомогательная функция, используемая, чтобы узнать, имеют ли два контейнера различных типов одно и то же содержимое в одинаковой последовательности.

size_t hashOf(T)(auto ref T arg, size_t seed = 0);

Вычисляет величину хэша аргумента arg с начальной величиной seed (семя). Результат может быть не равен typeid(T).getHash(&arg) Величина seed может быть использована для хэш-цепочки:

struct Test
{
    int a;
    string b;
    MyObject c;

    size_t toHash() const @safe pure nothrow
    {
        size_t hash = a.hashOf();
        hash = b.hashOf(hash);
        size_t h1 = c.myMegaHash();
        hash = h1.hashOf(hash); //Смешать два хэш-значения
        return hash;
    }
}

enum auto RTInfo(T);

Создать RTInfo для типа T

@property auto dup(T)(T[] a)
if (!is(const(T) : T));

@property T[] dup(T)(const(T)[] a)
if (is(const(T) : T));

Предоставляет свойство массива .dup.

@property immutable(T)[] idup(T)(T[] a);

@property immutable(T)[] idup(T : void)(const(T)[] a);

Предоставляет свойство массива .idup.