std.bitmanip

Средства для манипулирования битами.

Категория	Функции
Битовые конструкции	`BitArray` `bitfields` `bitsSet`
Преобразование порядка байтов	`bigEndianToNative` `littleEndianToNative` `nativeToBigEndian` `nativeToLittleEndian` `swapEndian`
Целочисленные диапазоны	`append` `peek` `read` `write`
Манипуляции с плавающей точкой	`DoubleRep` `FloatRep`
Тегирование	`taggedClassRef` `taggedPointer`

Лицензия:: Лицензия Boost 1.0.

Авторы:: Walter Bright, Andrei Alexandrescu, Jonathan M Davis, Alex Rønne Petersen, Damian Ziemba, Amaury SECHET

Исходный код: std/bitmanip.d

template bitfields(T...)

Позволяет создавать битовые поля внутри структур и классов.

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

См. также:: std.typecons.BitFlags

Примеры:

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

struct A
{
    int a;
    mixin(bitfields!(
        uint, "x",    2,
        int,  "y",    3,
        uint, "z",    2,
        bool, "flag", 1));
}

A obj;
obj.x = 2;
obj.z = obj.x;

writeln(obj.x); // 2
writeln(obj.y); // 0
writeln(obj.z); // 2
writeln(obj.flag); // false

Примеры:

Сумма всех длин битов в одной инстанции bitfield должна быть ровно 8, 16, 32 или 64. Если требуется дополнение, просто добавьте битовое поле с пустым именем.

struct A
{
    mixin(bitfields!(
        bool, "flag1",    1,
        bool, "flag2",    1,
        uint, "",         6));
}

A a;
writeln(a.flag1); // 0
a.flag1 = 1;
writeln(a.flag1); // 1
a.flag1 = 0;
writeln(a.flag1); // 0

Примеры:

Перечисления также могут использоваться

enum ABC { A, B, C }
struct EnumTest
{
    mixin(bitfields!(
              ABC, "x", 2,
              bool, "y", 1,
              ubyte, "z", 5));
}

enum auto taggedPointer(T : T*, string name, Ts...);

Этот генератор миксинов со строками позволяет создавать помеченные указатели внутри структур и классов.

Помеченный указатель использует биты, которые известны как нулевые в обычном указателе или ссылке на класс, для хранения дополнительной информации. Например, указатель на целое число должен быть выровнен по 4 байтам, поэтому есть 2 бита, которые всегда известны как нулевые. Можно хранить 2-битовое целое число там.

Приведенный выше пример создает помеченный указатель в структуре A. Указатель имеет тип uint*, как указано первым аргументом, и называется x, как указано вторым аргументом.

Следующие аргументы работают так же, как и у bitfield. Битовое поле должно поместиться в биты, которые известны как нулевые из-за выравнивания указателя.

Примеры:

struct A
{
    int a;
    mixin(taggedPointer!(
        uint*, "x",
        bool, "b1", 1,
        bool, "b2", 1));
}
A obj;
obj.x = new uint;
obj.b1 = true;
obj.b2 = false;

template taggedClassRef(T, string name, Ts...) if (is(T == class))

Этот генератор миксинов со строками позволяет создавать помеченные ссылки на классы внутри структур и классов.

Помеченная ссылка на класс использует биты, которые известны как нулевые в обычной ссылке на класс, для хранения дополнительной информации. Например, указатель на целое число должен быть выровнен по 4 байтам, поэтому есть 2 бита, которые всегда известны как нулевые. Можно хранить 2-битовое целое число там.

Приведенный выше пример создаёт помеченную ссылку на объект в структуре A. Это требует тех же параметров, что и taggedPointer, за исключением первого аргумента, который должен быть типом класса вместо типа указателя.

Примеры:

struct A
{
    int a;
    mixin(taggedClassRef!(
        Object, "o",
        uint, "i", 2));
}
A obj;
obj.o = new Object();
obj.i = 3;

struct FloatRep;

Позволяет отдельно манипулировать частями дробной, экспоненциальной и знаковой частей числа с плавающей точкой.

Определение:

struct FloatRep
{
    union
    {
        float value;
        mixin(bitfields!(
                  uint,  "fraction", 23,
                  ubyte, "exponent",  8,
                  bool,  "sign",      1));
    }
    enum uint bias = 127, fractionBits = 23, exponentBits = 8, signBits = 1;
}

Примеры:

FloatRep rep = {value: 0};
writeln(rep.fraction); // 0
writeln(rep.exponent); // 0
assert(!rep.sign);

rep.value = 42;
writeln(rep.fraction); // 2621440
writeln(rep.exponent); // 132
assert(!rep.sign);

rep.value = 10;
writeln(rep.fraction); // 2097152
writeln(rep.exponent); // 130

Примеры:

FloatRep rep = {value: 1};
writeln(rep.fraction); // 0
writeln(rep.exponent); // 127
assert(!rep.sign);

rep.exponent = 126;
writeln(rep.value); // 0.5

rep.exponent = 130;
writeln(rep.value); // 8

Примеры:

FloatRep rep = {value: 1};
rep.value = -0.5;
writeln(rep.fraction); // 0
writeln(rep.exponent); // 126
assert(rep.sign);

rep.value = -1. / 3;
writeln(rep.fraction); // 2796203
writeln(rep.exponent); // 125
assert(rep.sign);

struct DoubleRep;

Позволяет отдельно манипулировать частями дробной, экспоненциальной и знаковой частей числа с двойной точностью.

Определение:

struct DoubleRep
{
    union
    {
        double value;
        mixin(bitfields!(
                  ulong,   "fraction", 52,
                  ushort,  "exponent", 11,
                  bool,    "sign",      1));
    }
    enum uint bias = 1023, signBits = 1, fractionBits = 52, exponentBits = 11;
}

Примеры:

DoubleRep rep = {value: 0};
writeln(rep.fraction); // 0
writeln(rep.exponent); // 0
assert(!rep.sign);

rep.value = 42;
writeln(rep.fraction); // 1407374883553280
writeln(rep.exponent); // 1028
assert(!rep.sign);

rep.value = 10;
writeln(rep.fraction); // 1125899906842624
writeln(rep.exponent); // 1026

Примеры:

DoubleRep rep = {value: 1};
writeln(rep.fraction); // 0
writeln(rep.exponent); // 1023
assert(!rep.sign);

rep.exponent = 1022;
writeln(rep.value); // 0.5

rep.exponent = 1026;
writeln(rep.value); // 8

Примеры:

DoubleRep rep = {value: 1};
rep.value = -0.5;
writeln(rep.fraction); // 0
writeln(rep.exponent); // 1022
assert(rep.sign);

rep.value = -1. / 3;
writeln(rep.fraction); // 1501199875790165
writeln(rep.exponent); // 1021
assert(rep.sign);

Примеры:

Чтение

DoubleRep x;
x.value = 1.0;
assert(x.fraction == 0 && x.exponent == 1023 && !x.sign);
x.value = -0.5;
assert(x.fraction == 0 && x.exponent == 1022 && x.sign);
x.value = 0.5;
assert(x.fraction == 0 && x.exponent == 1022 && !x.sign);

Примеры:

Запись

DoubleRep x;
x.fraction = 1125899906842624;
x.exponent = 1025;
x.sign = true;
writeln(x.value); // -5.0

pure nothrow this(in bool[] ba);

Создаёт BitArray из массива bool, при этом значения, считываемые слева направо, соответствуют последовательным битам в BitArray.

Параметры:

bool[] ba Исходный массив значений bool.

Примеры:

import std.algorithm.comparison : equal;

bool[] input = [true, false, false, true, true];
auto a = BitArray(input);
writeln(a.length); // 5
assert(a.bitsSet.equal([0, 3, 4]));

// This also works because an implicit cast to bool[] occurs for this array.
auto b = BitArray([0, 0, 1]);
writeln(b.length); // 3
assert(b.bitsSet.equal([2]));

Примеры:

import std.algorithm.comparison : equal;
import std.array : array;
import std.range : iota, repeat;

BitArray a = true.repeat(70).array;
writeln(a.length); // 70
assert(a.bitsSet.equal(iota(0, 70)));

pure nothrow @nogc this(void[] v, size_t numbits);

Создаёт BitArray из исходного массива ссылок. Исходный массив не копируется, а служит основой массива битов, хранящего данные в виде size_t единиц.

Это означает, что необходимо обращать внимание при передаче массива типа отличного от size_t, во-первых, потому что его длина должна быть кратной size_t.sizeof, а во-вторых, из-за того, как отображаются биты:

size_t[] source = [1, 2, 3, 3424234, 724398, 230947, 389492];
enum sbits = size_t.sizeof * 8;
auto ba = BitArray(source, source.length * sbits);
foreach (n; 0 .. source.length * sbits)
{
    auto nth_bit = cast(bool) (source[n / sbits] & (1L << (n % sbits)));
    assert(ba[n] == nth_bit);
}

Самый младший бит в любой size_t единице является стартовым битом этой единицы, а самый старший бит — последним битом этой единицы. Таким образом, передача, например, массива int может привести к другому BitArray в зависимости от порядка байтов процессора.

Этот конструктор является обратным для opCast.

Параметры:

void[] `v`	Исходный массив. `v.length` должен быть кратным `size_t.sizeof`.
size_t `numbits`	Количество битов, подлежащих отображению из исходного массива, т.е. длина создаваемого `BitArray`.

Примеры:

import std.algorithm.comparison : equal;

auto a = BitArray([1, 0, 0, 1, 1]);

// Inverse of the cast.
auto v = cast(void[]) a;
auto b = BitArray(v, a.length);

writeln(b.length); // 5
assert(b.bitsSet.equal([0, 3, 4]));

// a and b share the underlying data.
a[0] = 0;
writeln(b[0]); // 0
writeln(a); // b

Примеры:

import std.algorithm.comparison : equal;

size_t[] source = [0b1100, 0b0011];
enum sbits = size_t.sizeof * 8;
auto ba = BitArray(source, source.length * sbits);
// The least significant bit in each unit is this unit's starting bit.
assert(ba.bitsSet.equal([2, 3, sbits, sbits + 1]));

Примеры:

// Example from the doc for this constructor.
static immutable size_t[] sourceData = [1, 0b101, 3, 3424234, 724398, 230947, 389492];
size_t[] source = sourceData.dup;
enum sbits = size_t.sizeof * 8;
auto ba = BitArray(source, source.length * sbits);
foreach (n; 0 .. source.length * sbits)
{
    auto nth_bit = cast(bool) (source[n / sbits] & (1L << (n % sbits)));
    writeln(ba[n]); // nth_bit
}

// Example of mapping only part of the array.
import std.algorithm.comparison : equal;

auto bc = BitArray(source, sbits + 1);
assert(bc.bitsSet.equal([0, sbits]));
// Source array has not been modified.
writeln(source); // sourceData

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

Возвращает:: Размерность, т.е. количество базовых слов, поддерживающих этот BitArray. Технически, это длина базового массива, хранящего биты, которая равна ceil(length / (size_t.sizeof * 8)), так как биты упакованы в size_t единицы.

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

Возвращает:: Количество битов в BitArray.

pure nothrow @property @system size_t length(size_t newlen);

Устанавливает количество битов в BitArray. Предупреждение: увеличение длины может перезаписать биты в последнем слове текущих данных независимо от того, совместно ли они используются между объектами BitArray. т.е. семантика расширения динамического массива D не соблюдается.

const pure nothrow @nogc bool opIndex(size_t i);

Получает i-й бит в BitArray.

Примеры:

static void fun(const BitArray arr)
{
    auto x = arr[0];
    writeln(x); // 1
}
BitArray a;
a.length = 3;
a[0] = 1;
fun(a);

pure nothrow @nogc bool opIndexAssign(bool b, size_t i);

Устанавливает i-й бит в BitArray.

pure nothrow @nogc void opSliceAssign(bool val);

Устанавливает все значения в BitArray в значение, заданное val.

Примеры:

import std.algorithm.comparison : equal;

auto b = BitArray([1, 0, 1, 0, 1, 1]);

b[] = true;
// all bits are set
assert(b.bitsSet.equal([0, 1, 2, 3, 4, 5]));

b[] = false;
// none of the bits are set
assert(b.bitsSet.empty);

pure nothrow @nogc void opSliceAssign(bool val, size_t start, size_t end);

Устанавливает биты среза BitArray, начиная с индекса start и заканчивая индексом ($D end - 1) значениями, указанными val.

Примеры:

import std.algorithm.comparison : equal;
import std.range : iota;
import std.stdio;

auto b = BitArray([1, 0, 0, 0, 1, 1, 0]);
b[1 .. 3] = true;
assert(b.bitsSet.equal([0, 1, 2, 4, 5]));

bool[72] bitArray;
auto b1 = BitArray(bitArray);
b1[63 .. 67] = true;
assert(b1.bitsSet.equal([63, 64, 65, 66]));
b1[63 .. 67] = false;
assert(b1.bitsSet.empty);
b1[0 .. 64] = true;
assert(b1.bitsSet.equal(iota(0, 64)));
b1[0 .. 64] = false;
assert(b1.bitsSet.empty);

bool[256] bitArray2;
auto b2 = BitArray(bitArray2);
b2[3 .. 245] = true;
assert(b2.bitsSet.equal(iota(3, 245)));
b2[3 .. 245] = false;
assert(b2.bitsSet.empty);

pure nothrow @nogc void flip();

Инвертирует все биты в BitArray

Примеры:

import std.algorithm.comparison : equal;
import std.range : iota;

// positions 0, 2, 4 are set
auto b = BitArray([1, 0, 1, 0, 1, 0]);
b.flip();
// after flipping, positions 1, 3, 5 are set
assert(b.bitsSet.equal([1, 3, 5]));

bool[270] bits;
auto b1 = BitArray(bits);
b1.flip();
assert(b1.bitsSet.equal(iota(0, 270)));

pure nothrow @nogc void flip(size_t i);

Инвертирует отдельный бит, указанный pos

Примеры:

auto ax = BitArray([1, 0, 0, 1]);
ax.flip(0);
writeln(ax[0]); // 0

bool[200] y;
y[90 .. 130] = true;
auto ay = BitArray(y);
ay.flip(100);
writeln(ay[100]); // 0

const pure nothrow @nogc size_t count();

Считает все установленные биты в BitArray

Примеры:

auto a = BitArray([0, 1, 1, 0, 0, 1, 1]);
writeln(a.count); // 4

BitArray b;
writeln(b.count); // 0

bool[200] boolArray;
boolArray[45 .. 130] = true;
auto c = BitArray(boolArray);
writeln(c.count); // 85

const pure nothrow @property BitArray dup();

Создаёт копию BitArray и её содержимого.

Примеры:

BitArray a;
BitArray b;

a.length = 3;
a[0] = 1; a[1] = 0; a[2] = 1;
b = a.dup;
writeln(b.length); // 3
foreach (i; 0 .. 3)
    writeln(b[i]); // (((i ^ 1) & 1) ? true : false)

int opApply(scope int delegate(ref bool) dg);

const int opApply(scope int delegate(bool) dg);

int opApply(scope int delegate(size_t, ref bool) dg);

const int opApply(scope int delegate(size_t, bool) dg);

Поддержка циклов foreach для BitArray.

Примеры:

bool[] ba = [1,0,1];

auto a = BitArray(ba);

int i;
foreach (b;a)
{
    switch (i)
    {
        case 0: assert(b == true); break;
        case 1: assert(b == false); break;
        case 2: assert(b == true); break;
        default: assert(0);
    }
    i++;
}

foreach (j,b;a)
{
    switch (j)
    {
        case 0: assert(b == true); break;
        case 1: assert(b == false); break;
        case 2: assert(b == true); break;
        default: assert(0);
    }
}

pure nothrow @nogc @property BitArray reverse();

Инвертирует биты BitArray.

Примеры:

BitArray b;
bool[5] data = [1,0,1,1,0];

b = BitArray(data);
b.reverse;
foreach (i; 0 .. data.length)
    writeln(b[i]); // data[4 - i]

pure nothrow @nogc @property BitArray sort();

Сортирует элементы BitArray.

Примеры:

size_t x = 0b1100011000;
auto ba = BitArray(10, &x);
ba.sort;
foreach (i; 0 .. 6)
    writeln(ba[i]); // false
foreach (i; 6 .. 10)
    writeln(ba[i]); // true

const pure nothrow @nogc bool opEquals(ref const BitArray a2);

Поддержка операторов == и != для BitArray.

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1];
bool[] bc = [1,0,1,0,1,0,1];
bool[] bd = [1,0,1,1,1];
bool[] be = [1,0,1,0,1];
bool[] bf = [1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
bool[] bg = [1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1];

auto a = BitArray(ba);
auto b = BitArray(bb);
auto c = BitArray(bc);
auto d = BitArray(bd);
auto e = BitArray(be);
auto f = BitArray(bf);
auto g = BitArray(bg);

assert(a != b);
assert(a != c);
assert(a != d);
writeln(a); // e
assert(f != g);

const pure nothrow @nogc int opCmp(BitArray a2);

Поддержка операторов сравнения для BitArray.

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1];
bool[] bc = [1,0,1,0,1,0,1];
bool[] bd = [1,0,1,1,1];
bool[] be = [1,0,1,0,1];
bool[] bf = [1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1];
bool[] bg = [1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);
auto c = BitArray(bc);
auto d = BitArray(bd);
auto e = BitArray(be);
auto f = BitArray(bf);
auto g = BitArray(bg);

assert(a >  b);
assert(a >= b);
assert(a <  c);
assert(a <= c);
assert(a <  d);
assert(a <= d);
writeln(a); // e
assert(a <= e);
assert(a >= e);
assert(f <  g);
assert(g <= g);

const pure nothrow @nogc size_t toHash();

Поддержка хеширования для BitArray.

inout pure nothrow @nogc inout(void)[] opCast(T : const(void[]))();

Преобразование в void[].

inout pure nothrow @nogc inout(size_t)[] opCast(T : const(size_t[]))();

Преобразование в size_t[].

Примеры:

import std.array : array;
import std.range : repeat, take;

// bit array with 300 elements
auto a = BitArray(true.repeat.take(300).array);
size_t[] v = cast(size_t[]) a;
const blockSize = size_t.sizeof * 8;
writeln(v.length); // (a.length + blockSize - 1) / blockSize

const pure nothrow BitArray opUnary(string op)()
Constraints: if (op == "~");

Поддержка унарного оператора ~ для BitArray.

Примеры:

bool[] ba = [1,0,1,0,1];

auto a = BitArray(ba);
BitArray b = ~a;

writeln(b[0]); // 0
writeln(b[1]); // 1
writeln(b[2]); // 0
writeln(b[3]); // 1
writeln(b[4]); // 0

const pure nothrow BitArray opBinary(string op)(const BitArray e2)
Constraints: if (op == "-" || op == "&" || op == "|" || op == "^");

Поддержка битовых операторов для BitArray.

Примеры:

static bool[] ba = [1,0,1,0,1];
static bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

BitArray c = a & b;

writeln(c[0]); // 1
writeln(c[1]); // 0
writeln(c[2]); // 1
writeln(c[3]); // 0
writeln(c[4]); // 0

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

BitArray c = a | b;

writeln(c[0]); // 1
writeln(c[1]); // 0
writeln(c[2]); // 1
writeln(c[3]); // 1
writeln(c[4]); // 1

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

BitArray c = a ^ b;

writeln(c[0]); // 0
writeln(c[1]); // 0
writeln(c[2]); // 0
writeln(c[3]); // 1
writeln(c[4]); // 1

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

BitArray c = a - b;

writeln(c[0]); // 0
writeln(c[1]); // 0
writeln(c[2]); // 0
writeln(c[3]); // 0
writeln(c[4]); // 1

pure nothrow @nogc BitArray opOpAssign(string op)(const BitArray e2)
Constraints: if (op == "-" || op == "&" || op == "|" || op == "^");

Поддержка оператора op= для BitArray.

Примеры:

bool[] ba = [1,0,1,0,1,1,0,1,0,1];
bool[] bb = [1,0,1,1,0];
auto a = BitArray(ba);
auto b = BitArray(bb);
BitArray c = a;
c.length = 5;
c &= b;
writeln(a[5]); // 1
writeln(a[6]); // 0
writeln(a[7]); // 1
writeln(a[8]); // 0
writeln(a[9]); // 1

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

a &= b;
writeln(a[0]); // 1
writeln(a[1]); // 0
writeln(a[2]); // 1
writeln(a[3]); // 0
writeln(a[4]); // 0

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

a |= b;
writeln(a[0]); // 1
writeln(a[1]); // 0
writeln(a[2]); // 1
writeln(a[3]); // 1
writeln(a[4]); // 1

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

a ^= b;
writeln(a[0]); // 0
writeln(a[1]); // 0
writeln(a[2]); // 0
writeln(a[3]); // 1
writeln(a[4]); // 1

Примеры:

bool[] ba = [1,0,1,0,1];
bool[] bb = [1,0,1,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);

a -= b;
writeln(a[0]); // 0
writeln(a[1]); // 0
writeln(a[2]); // 0
writeln(a[3]); // 0
writeln(a[4]); // 1

pure nothrow BitArray opOpAssign(string op)(bool b)
Constraints: if (op == "~");

pure nothrow BitArray opOpAssign(string op)(BitArray b)
Constraints: if (op == "~");

Поддержка оператора ~= для BitArray. Предупреждение: это перезапишет бит в последнем слове текущих данных независимо от того, совместно ли они используются между объектами BitArray. т.е. семантика конкатенации динамических массивов D не соблюдается

Примеры:

bool[] ba = [1,0,1,0,1];

auto a = BitArray(ba);
BitArray b;

b = (a ~= true);
writeln(a[0]); // 1
writeln(a[1]); // 0
writeln(a[2]); // 1
writeln(a[3]); // 0
writeln(a[4]); // 1
writeln(a[5]); // 1

writeln(b); // a

Примеры:

bool[] ba = [1,0];
bool[] bb = [0,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);
BitArray c;

c = (a ~= b);
writeln(a.length); // 5
writeln(a[0]); // 1
writeln(a[1]); // 0
writeln(a[2]); // 0
writeln(a[3]); // 1
writeln(a[4]); // 0

writeln(c); // a

const pure nothrow BitArray opBinary(string op)(bool b)
Constraints: if (op == "~");

const pure nothrow BitArray opBinaryRight(string op)(bool b)
Constraints: if (op == "~");

const pure nothrow BitArray opBinary(string op)(BitArray b)
Constraints: if (op == "~");

Поддержка бинарного оператора ~ для BitArray.

Примеры:

bool[] ba = [1,0];
bool[] bb = [0,1,0];

auto a = BitArray(ba);
auto b = BitArray(bb);
BitArray c;

c = (a ~ b);
writeln(c.length); // 5
writeln(c[0]); // 1
writeln(c[1]); // 0
writeln(c[2]); // 0
writeln(c[3]); // 1
writeln(c[4]); // 0

c = (a ~ true);
writeln(c.length); // 3
writeln(c[0]); // 1
writeln(c[1]); // 0
writeln(c[2]); // 1

c = (false ~ a);
writeln(c.length); // 3
writeln(c[0]); // 0
writeln(c[1]); // 1
writeln(c[2]); // 0

pure nothrow @nogc void opOpAssign(string op)(size_t nbits)
Constraints: if (op == "<<");

Поддержка оператора <<=.

Сдвигает все биты в массиве влево на заданное количество битов. Самые левые биты отбрасываются, а 0 добавляются в конец, чтобы заполнить освободившиеся биты.

Предупреждение: неиспользуемые биты в последнем слове до следующей границы слова могут быть перезаписаны этой операцией. Она не пытается сохранить биты, выходящие за пределы массива.

pure nothrow @nogc void opOpAssign(string op)(size_t nbits)
Constraints: if (op == ">>");

Поддержка оператора >>=.

Сдвигает все биты в массиве вправо на заданное количество битов. Самые правые биты отбрасываются, а нули вставляются в конец для заполнения освободившихся битов.

Предупреждение: неиспользуемые биты в последнем слове до следующей границы слова могут быть перезаписаны этой операцией. Она не пытается сохранить биты за пределами массива.

Примеры:

import std.format : format;

auto b = BitArray([1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1]);

b <<= 1;
writeln(format("%b", b)); // "01100_10101101"

b >>= 1;
writeln(format("%b", b)); // "11001_01011010"

b <<= 4;
writeln(format("%b", b)); // "00001_10010101"

b >>= 5;
writeln(format("%b", b)); // "10010_10100000"

b <<= 13;
writeln(format("%b", b)); // "00000_00000000"

b = BitArray([1, 0, 1, 1, 0, 1, 1, 1]);
b >>= 8;
writeln(format("%b", b)); // "00000000"

const void toString(W)(ref W sink, ref scope const FormatSpec!char fmt)
Constraints: if (isOutputRange!(W, char));

Возвращает строковое представление этого BitArray.

Поддерживаются два спецификатора формата:

%s, который выводит биты как массив, и

%b, который выводит биты как 8-битные байтовые пакеты

разделенные подчеркиванием.

Параметры:

W `sink`	`char` принимающий диапазон вывода.
FormatSpec!char `fmt`	`std.format.FormatSpec`, который управляет отображением данных.

Примеры:

import std.format : format;

auto b = BitArray([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]);

auto s1 = format("%s", b);
writeln(s1); // "[0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]"

auto s2 = format("%b", b);
writeln(s2); // "00001111_00001111"

const nothrow @property auto bitsSet();

Возвращает ленивый диапазон индексов установленных битов.

Примеры:

import std.algorithm.comparison : equal;

auto b1 = BitArray([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]);
assert(b1.bitsSet.equal([4, 5, 6, 7, 12, 13, 14, 15]));

BitArray b2;
b2.length = 1000;
b2[333] = true;
b2[666] = true;
b2[999] = true;
assert(b2.bitsSet.equal([333, 666, 999]));

pure nothrow @nogc @safe T swapEndian(T)(const T val)
Constraints: if (isIntegral!T || isSomeChar!T || isBoolean!T);

Меняет порядок следования байтов (эндианность) заданного целочисленного значения или символа.

Примеры:

writeln(42.swapEndian); // 704643072
assert(42.swapEndian.swapEndian == 42); // reflexive
writeln(1.swapEndian); // 16777216

writeln(true.swapEndian); // true
writeln(byte(10).swapEndian); // 10
writeln(char(10).swapEndian); // 10

writeln(ushort(10).swapEndian); // 2560
writeln(long(10).swapEndian); // 720575940379279360
writeln(ulong(10).swapEndian); // 720575940379279360

pure nothrow @nogc @safe auto nativeToBigEndian(T)(const T val)
Constraints: if (canSwapEndianness!T);

Преобразует заданное значение из родного порядка байтов в порядок байтов big-endian и возвращает его как ubyte[n], где n — размер данного типа.

Возвращение ubyte[n] помогает предотвратить случайное использование переставленного значения как обычного (и в случае с плавающей точкой это необходимо, так как FPU нарушит любые переставленные значения с плавающей точкой. Поэтому у вас не могут быть значения с плавающей точкой с измененным порядком байтов как обычные значения с плавающей точкой).

real не поддерживается, потому что его размер зависит от реализации и, следовательно, может различаться на разных машинах (что может сделать его непригодным для переноса на другую машину).

Примеры:

int i = 12345;
ubyte[4] swappedI = nativeToBigEndian(i);
writeln(i); // bigEndianToNative!int(swappedI)

float f = 123.45f;
ubyte[4] swappedF = nativeToBigEndian(f);
writeln(f); // bigEndianToNative!float(swappedF)

const float cf = 123.45f;
ubyte[4] swappedCF = nativeToBigEndian(cf);
writeln(cf); // bigEndianToNative!float(swappedCF)

double d = 123.45;
ubyte[8] swappedD = nativeToBigEndian(d);
writeln(d); // bigEndianToNative!double(swappedD)

const double cd = 123.45;
ubyte[8] swappedCD = nativeToBigEndian(cd);
writeln(cd); // bigEndianToNative!double(swappedCD)

pure nothrow @nogc @safe T bigEndianToNative(T, size_t n)(ubyte[n] val)
Constraints: if (canSwapEndianness!T && (n == T.sizeof));

Преобразует заданное значение из порядка байтов big-endian в родной порядок байтов и возвращает его. Значение предоставляется как ubyte[n], где n — размер целевого типа. Вы должны указать целевой тип в качестве шаблона аргумента, потому что существуют несколько типов с одинаковым размером, поэтому тип аргумента недостаточно, чтобы определить тип результата.

Примеры:

ushort i = 12345;
ubyte[2] swappedI = nativeToBigEndian(i);
writeln(i); // bigEndianToNative!ushort(swappedI)

dchar c = 'D';
ubyte[4] swappedC = nativeToBigEndian(c);
writeln(c); // bigEndianToNative!dchar(swappedC)

pure nothrow @nogc @safe auto nativeToLittleEndian(T)(const T val)
Constraints: if (canSwapEndianness!T);

Преобразует заданное значение из родного порядка байтов в порядок байтов little-endian и возвращает его как ubyte[n], где n — размер данного типа.

Примеры:

int i = 12345;
ubyte[4] swappedI = nativeToLittleEndian(i);
writeln(i); // littleEndianToNative!int(swappedI)

double d = 123.45;
ubyte[8] swappedD = nativeToLittleEndian(d);
writeln(d); // littleEndianToNative!double(swappedD)

pure nothrow @nogc @safe T littleEndianToNative(T, size_t n)(ubyte[n] val)
Constraints: if (canSwapEndianness!T && (n == T.sizeof));

Преобразует заданное значение из порядка байтов little-endian в родной порядок байтов и возвращает его. Значение предоставляется как ubyte[n], где n — размер целевого типа. Вы должны указать целевой тип в качестве шаблона аргумента, потому что существуют несколько типов с одинаковым размером, поэтому тип аргумента недостаточно, чтобы определить тип результата.

Использование ubyte[n] помогает предотвратить случайное использование переставленного значения как обычного (и в случае с плавающей точкой это необходимо, так как FPU нарушит любые переставленные значения с плавающей точкой. Поэтому у вас не могут быть значения с плавающей точкой с измененным порядком байтов как обычные значения с плавающей точкой).

real не поддерживается, потому что его размер зависит от реализации и, следовательно, может различаться на разных машинах (что может сделать его непригодным для переноса на другую машину).

Примеры:

ushort i = 12345;
ubyte[2] swappedI = nativeToLittleEndian(i);
writeln(i); // littleEndianToNative!ushort(swappedI)

dchar c = 'D';
ubyte[4] swappedC = nativeToLittleEndian(c);
writeln(c); // littleEndianToNative!dchar(swappedC)

T peek(T, Endian endianness = Endian.bigEndian, R)(R range)
Constraints: if (canSwapEndianness!T && isForwardRange!R && is(ElementType!R : const(ubyte)));

T peek(T, Endian endianness = Endian.bigEndian, R)(R range, size_t index)
Constraints: if (canSwapEndianness!T && isForwardRange!R && hasSlicing!R && is(ElementType!R : const(ubyte)));

T peek(T, Endian endianness = Endian.bigEndian, R)(R range, size_t* index)
Constraints: if (canSwapEndianness!T && isForwardRange!R && hasSlicing!R && is(ElementType!R : const(ubyte)));

Берет диапазон ubyte и преобразует первые T.sizeof байта в T. Возвращаемое значение преобразуется из заданного порядка байтов в родной порядок. Диапазон не расходуется.

Параметры:

T	Целевой целочисленный тип для преобразования первых `T.sizeof` байтов.
endianness	Порядок байтов, в котором предполагается хранение байтов.
R `range`	Диапазон для чтения.
size_t `index`	Индекс для начала чтения (вместо начала с первого элемента). Если индекс — указатель, он обновляется до индекса после чтения байтов. Перегрузки с индексом доступны только если `hasSlicing!R` является `true`.

Примеры:

ubyte[] buffer = [1, 5, 22, 9, 44, 255, 8];
writeln(buffer.peek!uint()); // 17110537
writeln(buffer.peek!ushort()); // 261
writeln(buffer.peek!ubyte()); // 1

writeln(buffer.peek!uint(2)); // 369700095
writeln(buffer.peek!ushort(2)); // 5641
writeln(buffer.peek!ubyte(2)); // 22

size_t index = 0;
writeln(buffer.peek!ushort(&index)); // 261
writeln(index); // 2

writeln(buffer.peek!uint(&index)); // 369700095
writeln(index); // 6

writeln(buffer.peek!ubyte(&index)); // 8
writeln(index); // 7

Примеры:

import std.algorithm.iteration : filter;
ubyte[] buffer = [1, 5, 22, 9, 44, 255, 7];
auto range = filter!"true"(buffer);
writeln(range.peek!uint()); // 17110537
writeln(range.peek!ushort()); // 261
writeln(range.peek!ubyte()); // 1

T read(T, Endian endianness = Endian.bigEndian, R)(ref R range)
Constraints: if (canSwapEndianness!T && isInputRange!R && is(ElementType!R : const(ubyte)));

Берет диапазон ubyte и преобразует первые T.sizeof байта в T. Возвращаемое значение преобразуется из заданного порядка байтов в родной порядок. T.sizeof байта, которые читаются, потребляются из диапазона.

Параметры:

T	Целевой целочисленный тип для преобразования первых `T.sizeof` байтов.
endianness	Порядок байтов, в котором предполагается хранение байтов.
R `range`	Диапазон для чтения.

Примеры:

import std.range.primitives : empty;
ubyte[] buffer = [1, 5, 22, 9, 44, 255, 8];
writeln(buffer.length); // 7

writeln(buffer.read!ushort()); // 261
writeln(buffer.length); // 5

writeln(buffer.read!uint()); // 369700095
writeln(buffer.length); // 1

writeln(buffer.read!ubyte()); // 8
assert(buffer.empty);

void write(T, Endian endianness = Endian.bigEndian, R)(R range, const T value, size_t index)
Constraints: if (canSwapEndianness!T && isForwardRange!R && hasSlicing!R && is(ElementType!R : ubyte));

void write(T, Endian endianness = Endian.bigEndian, R)(R range, const T value, size_t* index)
Constraints: if (canSwapEndianness!T && isForwardRange!R && hasSlicing!R && is(ElementType!R : ubyte));

Берет целое значение, преобразует его в заданный порядок байтов и записывает его в заданный диапазон ubyte как последовательность T.sizeof ubyte начиная с индекса. hasSlicing!R должен быть true.

Параметры:

T	Целевой целочисленный тип для преобразования первых `T.sizeof` байтов.
endianness	Порядок байтов, в котором необходимо записать байты.
R `range`	Диапазон для записи.
T `value`	Значение для записи.
size_t `index`	Индекс для начала записи. Если индекс — указатель, он обновляется до индекса после записи байтов.

Примеры:

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];
buffer.write!uint(29110231u, 0);
writeln(buffer); // [1, 188, 47, 215, 0, 0, 0, 0]

buffer.write!ushort(927, 0);
writeln(buffer); // [3, 159, 47, 215, 0, 0, 0, 0]

buffer.write!ubyte(42, 0);
writeln(buffer); // [42, 159, 47, 215, 0, 0, 0, 0]

Примеры:

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0];
buffer.write!uint(142700095u, 2);
writeln(buffer); // [0, 0, 8, 129, 110, 63, 0, 0, 0]

buffer.write!ushort(19839, 2);
writeln(buffer); // [0, 0, 77, 127, 110, 63, 0, 0, 0]

buffer.write!ubyte(132, 2);
writeln(buffer); // [0, 0, 132, 127, 110, 63, 0, 0, 0]

Примеры:

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];
size_t index = 0;
buffer.write!ushort(261, &index);
writeln(buffer); // [1, 5, 0, 0, 0, 0, 0, 0]
writeln(index); // 2

buffer.write!uint(369700095u, &index);
writeln(buffer); // [1, 5, 22, 9, 44, 255, 0, 0]
writeln(index); // 6

buffer.write!ubyte(8, &index);
writeln(buffer); // [1, 5, 22, 9, 44, 255, 8, 0]
writeln(index); // 7

Примеры:

bool

ubyte[] buffer = [0, 0];
buffer.write!bool(false, 0);
writeln(buffer); // [0, 0]

buffer.write!bool(true, 0);
writeln(buffer); // [1, 0]

buffer.write!bool(true, 1);
writeln(buffer); // [1, 1]

buffer.write!bool(false, 1);
writeln(buffer); // [1, 0]

size_t index = 0;
buffer.write!bool(false, &index);
writeln(buffer); // [0, 0]
writeln(index); // 1

buffer.write!bool(true, &index);
writeln(buffer); // [0, 1]
writeln(index); // 2

Примеры:

char(8-bit)

ubyte[] buffer = [0, 0, 0];

buffer.write!char('a', 0);
writeln(buffer); // [97, 0, 0]

buffer.write!char('b', 1);
writeln(buffer); // [97, 98, 0]

size_t index = 0;
buffer.write!char('a', &index);
writeln(buffer); // [97, 98, 0]
writeln(index); // 1

buffer.write!char('b', &index);
writeln(buffer); // [97, 98, 0]
writeln(index); // 2

buffer.write!char('c', &index);
writeln(buffer); // [97, 98, 99]
writeln(index); // 3

Примеры:

wchar (16bit - 2x ubyte)

ubyte[] buffer = [0, 0, 0, 0];

buffer.write!wchar('ą', 0);
writeln(buffer); // [1, 5, 0, 0]

buffer.write!wchar('”', 2);
writeln(buffer); // [1, 5, 32, 29]

size_t index = 0;
buffer.write!wchar('ć', &index);
writeln(buffer); // [1, 7, 32, 29]
writeln(index); // 2

buffer.write!wchar('ą', &index);
writeln(buffer); // [1, 7, 1, 5]
writeln(index); // 4

Примеры:

dchar (32bit - 4x ubyte)

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];

buffer.write!dchar('ą', 0);
writeln(buffer); // [0, 0, 1, 5, 0, 0, 0, 0]

buffer.write!dchar('”', 4);
writeln(buffer); // [0, 0, 1, 5, 0, 0, 32, 29]

size_t index = 0;
buffer.write!dchar('ć', &index);
writeln(buffer); // [0, 0, 1, 7, 0, 0, 32, 29]
writeln(index); // 4

buffer.write!dchar('ą', &index);
writeln(buffer); // [0, 0, 1, 7, 0, 0, 1, 5]
writeln(index); // 8

Примеры:

float (32bit - 4x ubyte)

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];

buffer.write!float(32.0f, 0);
writeln(buffer); // [66, 0, 0, 0, 0, 0, 0, 0]

buffer.write!float(25.0f, 4);
writeln(buffer); // [66, 0, 0, 0, 65, 200, 0, 0]

size_t index = 0;
buffer.write!float(25.0f, &index);
writeln(buffer); // [65, 200, 0, 0, 65, 200, 0, 0]
writeln(index); // 4

buffer.write!float(32.0f, &index);
writeln(buffer); // [65, 200, 0, 0, 66, 0, 0, 0]
writeln(index); // 8

Примеры:

double (64bit - 8x ubyte)

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

buffer.write!double(32.0, 0);
writeln(buffer); // [64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

buffer.write!double(25.0, 8);
writeln(buffer); // [64, 64, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]

size_t index = 0;
buffer.write!double(25.0, &index);
writeln(buffer); // [64, 57, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]
writeln(index); // 8

buffer.write!double(32.0, &index);
writeln(buffer); // [64, 57, 0, 0, 0, 0, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0]
writeln(index); // 16

Примеры:

enum

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

enum Foo
{
    one = 10,
    two = 20,
    three = 30
}

buffer.write!Foo(Foo.one, 0);
writeln(buffer); // [0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0]

buffer.write!Foo(Foo.two, 4);
writeln(buffer); // [0, 0, 0, 10, 0, 0, 0, 20, 0, 0, 0, 0]

buffer.write!Foo(Foo.three, 8);
writeln(buffer); // [0, 0, 0, 10, 0, 0, 0, 20, 0, 0, 0, 30]

size_t index = 0;
buffer.write!Foo(Foo.three, &index);
writeln(buffer); // [0, 0, 0, 30, 0, 0, 0, 20, 0, 0, 0, 30]
writeln(index); // 4

buffer.write!Foo(Foo.one, &index);
writeln(buffer); // [0, 0, 0, 30, 0, 0, 0, 10, 0, 0, 0, 30]
writeln(index); // 8

buffer.write!Foo(Foo.two, &index);
writeln(buffer); // [0, 0, 0, 30, 0, 0, 0, 10, 0, 0, 0, 20]
writeln(index); // 12

Примеры:

enum - float

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];

enum Float: float
{
    one = 32.0f,
    two = 25.0f
}

buffer.write!Float(Float.one, 0);
writeln(buffer); // [66, 0, 0, 0, 0, 0, 0, 0]

buffer.write!Float(Float.two, 4);
writeln(buffer); // [66, 0, 0, 0, 65, 200, 0, 0]

size_t index = 0;
buffer.write!Float(Float.two, &index);
writeln(buffer); // [65, 200, 0, 0, 65, 200, 0, 0]
writeln(index); // 4

buffer.write!Float(Float.one, &index);
writeln(buffer); // [65, 200, 0, 0, 66, 0, 0, 0]
writeln(index); // 8

Примеры:

enum - double

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

enum Double: double
{
    one = 32.0,
    two = 25.0
}

buffer.write!Double(Double.one, 0);
writeln(buffer); // [64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

buffer.write!Double(Double.two, 8);
writeln(buffer); // [64, 64, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]

size_t index = 0;
buffer.write!Double(Double.two, &index);
writeln(buffer); // [64, 57, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]
writeln(index); // 8

buffer.write!Double(Double.one, &index);
writeln(buffer); // [64, 57, 0, 0, 0, 0, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0]
writeln(index); // 16

Примеры:

enum - real

ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

enum Real: real
{
    one = 32.0,
    two = 25.0
}

static assert(!__traits(compiles, buffer.write!Real(Real.one)));

void append(T, Endian endianness = Endian.bigEndian, R)(R range, const T value)
Constraints: if (canSwapEndianness!T && isOutputRange!(R, ubyte));

Принимает целое значение, преобразует его в указанную форму организации байтов, и добавляет его к заданному диапазону ubytes (используя put) в качестве последовательности T.sizeof ubytes, начиная с указанного индекса. hasSlicing!R должен быть true.

Параметры:

T	Целевой целочисленный тип для преобразования первых `T.sizeof` байтов.
endianness	Организация байтов для записи.
R `range`	Диапазон для добавления.
T `value`	Значение для добавления.

Примеры:

import std.array;
auto buffer = appender!(const ubyte[])();
buffer.append!ushort(261);
writeln(buffer.data); // [1, 5]

buffer.append!uint(369700095u);
writeln(buffer.data); // [1, 5, 22, 9, 44, 255]

buffer.append!ubyte(8);
writeln(buffer.data); // [1, 5, 22, 9, 44, 255, 8]

Примеры:

bool

import std.array : appender;
auto buffer = appender!(const ubyte[])();

buffer.append!bool(true);
writeln(buffer.data); // [1]

buffer.append!bool(false);
writeln(buffer.data); // [1, 0]

Примеры:

char wchar dchar

import std.array : appender;
auto buffer = appender!(const ubyte[])();

buffer.append!char('a');
writeln(buffer.data); // [97]

buffer.append!char('b');
writeln(buffer.data); // [97, 98]

buffer.append!wchar('ą');
writeln(buffer.data); // [97, 98, 1, 5]

buffer.append!dchar('ą');
    writeln(buffer.data); // [97, 98, 1, 5, 0, 0, 1, 5]

Примеры:

float double

import std.array : appender;
auto buffer = appender!(const ubyte[])();

buffer.append!float(32.0f);
writeln(buffer.data); // [66, 0, 0, 0]

buffer.append!double(32.0);
writeln(buffer.data); // [66, 0, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0]

Примеры:

enum

import std.array : appender;
auto buffer = appender!(const ubyte[])();

enum Foo
{
    one = 10,
    two = 20,
    three = 30
}

buffer.append!Foo(Foo.one);
writeln(buffer.data); // [0, 0, 0, 10]

buffer.append!Foo(Foo.two);
writeln(buffer.data); // [0, 0, 0, 10, 0, 0, 0, 20]

buffer.append!Foo(Foo.three);
writeln(buffer.data); // [0, 0, 0, 10, 0, 0, 0, 20, 0, 0, 0, 30]

Примеры:

enum - bool

import std.array : appender;
auto buffer = appender!(const ubyte[])();

enum Bool: bool
{
    bfalse = false,
    btrue = true,
}

buffer.append!Bool(Bool.btrue);
writeln(buffer.data); // [1]

buffer.append!Bool(Bool.bfalse);
writeln(buffer.data); // [1, 0]

buffer.append!Bool(Bool.btrue);
writeln(buffer.data); // [1, 0, 1]

Примеры:

enum - float

import std.array : appender;
auto buffer = appender!(const ubyte[])();

enum Float: float
{
    one = 32.0f,
    two = 25.0f
}

buffer.append!Float(Float.one);
writeln(buffer.data); // [66, 0, 0, 0]

buffer.append!Float(Float.two);
writeln(buffer.data); // [66, 0, 0, 0, 65, 200, 0, 0]

Примеры:

enum - double

import std.array : appender;
auto buffer = appender!(const ubyte[])();

enum Double: double
{
    one = 32.0,
    two = 25.0
}

buffer.append!Double(Double.one);
writeln(buffer.data); // [64, 64, 0, 0, 0, 0, 0, 0]

buffer.append!Double(Double.two);
writeln(buffer.data); // [64, 64, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]

Примеры:

enum - real

import std.array : appender;
auto buffer = appender!(const ubyte[])();

enum Real: real
{
    one = 32.0,
    two = 25.0
}

static assert(!__traits(compiles, buffer.append!Real(Real.one)));

pure nothrow @nogc auto bitsSet(T)(const T value)
Constraints: if (isIntegral!T);

Диапазон, который итерирует индексы установленных битов в value. Индекс 0 соответствует младшему биту. Для знаковых целых чисел наивысший индекс соответствует биту знака.

Примеры:

import std.algorithm.comparison : equal;
import std.range : iota;

assert(bitsSet(1).equal([0]));
assert(bitsSet(5).equal([0, 2]));
assert(bitsSet(-1).equal(iota(32)));
assert(bitsSet(int.min).equal([31]));