write

Takes an integral value, converts it to the given endianness, and writes it to the given range of ubytes as a sequence of T.sizeof ubytes starting at index. hasSlicing!R must be true.

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

Parameters

T: The integral type to convert the first T.sizeof bytes to.
endianness: The endianness to write the bytes in.
range R: The range to write to.
value T: The value to write.
index size_t: The index to start writing to. If index is a pointer, then it is updated to the index after the bytes read.

Examples

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

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

buffer.write!ubyte(42, 0);
assert(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);
assert(buffer == [0, 0, 8, 129, 110, 63, 0, 0, 0]);

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

buffer.write!ubyte(132, 2);
assert(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);
assert(buffer == [1, 5, 0, 0, 0, 0, 0, 0]);
assert(index == 2);

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

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

bool

1 ubyte[] buffer = [0, 0];
2 buffer.write!bool(false, 0);
3 assert(buffer == [0, 0]);
4 
5 buffer.write!bool(true, 0);
6 assert(buffer == [1, 0]);
7 
8 buffer.write!bool(true, 1);
9 assert(buffer == [1, 1]);
10 
11 buffer.write!bool(false, 1);
12 assert(buffer == [1, 0]);
13 
14 size_t index = 0;
15 buffer.write!bool(false, &index);
16 assert(buffer == [0, 0]);
17 assert(index == 1);
18 
19 buffer.write!bool(true, &index);
20 assert(buffer == [0, 1]);
21 assert(index == 2);

char(8-bit)

1 ubyte[] buffer = [0, 0, 0];
2 
3 buffer.write!char('a', 0);
4 assert(buffer == [97, 0, 0]);
5 
6 buffer.write!char('b', 1);
7 assert(buffer == [97, 98, 0]);
8 
9 size_t index = 0;
10 buffer.write!char('a', &index);
11 assert(buffer == [97, 98, 0]);
12 assert(index == 1);
13 
14 buffer.write!char('b', &index);
15 assert(buffer == [97, 98, 0]);
16 assert(index == 2);
17 
18 buffer.write!char('c', &index);
19 assert(buffer == [97, 98, 99]);
20 assert(index == 3);

wchar (16bit - 2x ubyte)

1 ubyte[] buffer = [0, 0, 0, 0];
2 
3 buffer.write!wchar('ą', 0);
4 assert(buffer == [1, 5, 0, 0]);
5 
6 buffer.write!wchar('”', 2);
7 assert(buffer == [1, 5, 32, 29]);
8 
9 size_t index = 0;
10 buffer.write!wchar('ć', &index);
11 assert(buffer == [1, 7, 32, 29]);
12 assert(index == 2);
13 
14 buffer.write!wchar('ą', &index);
15 assert(buffer == [1, 7, 1, 5]);
16 assert(index == 4);

dchar (32bit - 4x ubyte)

1 ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];
2 
3 buffer.write!dchar('ą', 0);
4 assert(buffer == [0, 0, 1, 5, 0, 0, 0, 0]);
5 
6 buffer.write!dchar('”', 4);
7 assert(buffer == [0, 0, 1, 5, 0, 0, 32, 29]);
8 
9 size_t index = 0;
10 buffer.write!dchar('ć', &index);
11 assert(buffer == [0, 0, 1, 7, 0, 0, 32, 29]);
12 assert(index == 4);
13 
14 buffer.write!dchar('ą', &index);
15 assert(buffer == [0, 0, 1, 7, 0, 0, 1, 5]);
16 assert(index == 8);

float (32bit - 4x ubyte)

1 ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];
2 
3 buffer.write!float(32.0f, 0);
4 assert(buffer == [66, 0, 0, 0, 0, 0, 0, 0]);
5 
6 buffer.write!float(25.0f, 4);
7 assert(buffer == [66, 0, 0, 0, 65, 200, 0, 0]);
8 
9 size_t index = 0;
10 buffer.write!float(25.0f, &index);
11 assert(buffer == [65, 200, 0, 0, 65, 200, 0, 0]);
12 assert(index == 4);
13 
14 buffer.write!float(32.0f, &index);
15 assert(buffer == [65, 200, 0, 0, 66, 0, 0, 0]);
16 assert(index == 8);

double (64bit - 8x ubyte)

1 ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
2 
3 buffer.write!double(32.0, 0);
4 assert(buffer == [64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
5 
6 buffer.write!double(25.0, 8);
7 assert(buffer == [64, 64, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]);
8 
9 size_t index = 0;
10 buffer.write!double(25.0, &index);
11 assert(buffer == [64, 57, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]);
12 assert(index == 8);
13 
14 buffer.write!double(32.0, &index);
15 assert(buffer == [64, 57, 0, 0, 0, 0, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0]);
16 assert(index == 16);

enum

1 ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
2 
3 enum Foo
4 {
5     one = 10,
6     two = 20,
7     three = 30
8 }
9 
10 buffer.write!Foo(Foo.one, 0);
11 assert(buffer == [0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0]);
12 
13 buffer.write!Foo(Foo.two, 4);
14 assert(buffer == [0, 0, 0, 10, 0, 0, 0, 20, 0, 0, 0, 0]);
15 
16 buffer.write!Foo(Foo.three, 8);
17 assert(buffer == [0, 0, 0, 10, 0, 0, 0, 20, 0, 0, 0, 30]);
18 
19 size_t index = 0;
20 buffer.write!Foo(Foo.three, &index);
21 assert(buffer == [0, 0, 0, 30, 0, 0, 0, 20, 0, 0, 0, 30]);
22 assert(index == 4);
23 
24 buffer.write!Foo(Foo.one, &index);
25 assert(buffer == [0, 0, 0, 30, 0, 0, 0, 10, 0, 0, 0, 30]);
26 assert(index == 8);
27 
28 buffer.write!Foo(Foo.two, &index);
29 assert(buffer == [0, 0, 0, 30, 0, 0, 0, 10, 0, 0, 0, 20]);
30 assert(index == 12);

enum - float

1 ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0];
2 
3 enum Float: float
4 {
5     one = 32.0f,
6     two = 25.0f
7 }
8 
9 buffer.write!Float(Float.one, 0);
10 assert(buffer == [66, 0, 0, 0, 0, 0, 0, 0]);
11 
12 buffer.write!Float(Float.two, 4);
13 assert(buffer == [66, 0, 0, 0, 65, 200, 0, 0]);
14 
15 size_t index = 0;
16 buffer.write!Float(Float.two, &index);
17 assert(buffer == [65, 200, 0, 0, 65, 200, 0, 0]);
18 assert(index == 4);
19 
20 buffer.write!Float(Float.one, &index);
21 assert(buffer == [65, 200, 0, 0, 66, 0, 0, 0]);
22 assert(index == 8);

enum - double

1 ubyte[] buffer = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
2 
3 enum Double: double
4 {
5     one = 32.0,
6     two = 25.0
7 }
8 
9 buffer.write!Double(Double.one, 0);
10 assert(buffer == [64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
11 
12 buffer.write!Double(Double.two, 8);
13 assert(buffer == [64, 64, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]);
14 
15 size_t index = 0;
16 buffer.write!Double(Double.two, &index);
17 assert(buffer == [64, 57, 0, 0, 0, 0, 0, 0, 64, 57, 0, 0, 0, 0, 0, 0]);
18 assert(index == 8);
19 
20 buffer.write!Double(Double.one, &index);
21 assert(buffer == [64, 57, 0, 0, 0, 0, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0]);
22 assert(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)));

write

Parameters

Examples

Meta

Source