441 lines
10 KiB
D
441 lines
10 KiB
D
module structs;
|
|
|
|
private
|
|
{
|
|
import core.exception;
|
|
import std.array;
|
|
import std.bitmanip;
|
|
import std.exception;
|
|
import std.system;
|
|
|
|
/++
|
|
+ Supported format types
|
|
+/
|
|
enum FORMAT_TYPE
|
|
{
|
|
INT_8, /// Signed integer 8 bit
|
|
INT_16, /// Signed integer 16 bit
|
|
INT_32, /// Signed integer 32 bit
|
|
INT_64, /// Signed integer 64 bit
|
|
UINT_8, /// Unsigned integer 8 bit
|
|
UINT_16, /// Unsigned integer 16 bit
|
|
UINT_32, /// Unsigned integer 32 bit
|
|
UINT_64, /// Unsigned integer 64 bit
|
|
STRING /// C-String
|
|
}
|
|
|
|
/++
|
|
+ A element of a package
|
|
+/
|
|
struct Element
|
|
{
|
|
Endian endian; /// The endian to use
|
|
bool is_array; /// If it's an array
|
|
size_t array_size; /// Array size
|
|
FORMAT_TYPE format_type; /// The formated type
|
|
|
|
/++
|
|
+ Calculate the size of the element
|
|
+ Returns: Size in bytes
|
|
+/
|
|
size_t packSize() const
|
|
{
|
|
// Base format type size
|
|
size_t base_size = 0;
|
|
final switch (this.format_type)
|
|
{
|
|
case FORMAT_TYPE.STRING:
|
|
case FORMAT_TYPE.INT_8:
|
|
case FORMAT_TYPE.UINT_8:
|
|
base_size = 1;
|
|
break;
|
|
case FORMAT_TYPE.INT_16:
|
|
case FORMAT_TYPE.UINT_16:
|
|
base_size = 2;
|
|
break;
|
|
case FORMAT_TYPE.INT_32:
|
|
case FORMAT_TYPE.UINT_32:
|
|
base_size = 4;
|
|
break;
|
|
case FORMAT_TYPE.INT_64:
|
|
case FORMAT_TYPE.UINT_64:
|
|
base_size = 8;
|
|
break;
|
|
}
|
|
|
|
// Add array size
|
|
return base_size * this.array_size;
|
|
}
|
|
|
|
static pure Element genFromString(string data)
|
|
in (data.length > 0, "Format can't be empty.")
|
|
{
|
|
// Pre checks
|
|
size_t current_pos = 0;
|
|
|
|
// Read endian
|
|
bool endian_explicit = false;
|
|
Endian endian_found = std.system.endian;
|
|
switch (data[0])
|
|
{
|
|
case '=':
|
|
endian_found = std.system.endian;
|
|
current_pos++;
|
|
endian_explicit = true;
|
|
break;
|
|
case '<':
|
|
endian_found = Endian.littleEndian;
|
|
current_pos++;
|
|
endian_explicit = true;
|
|
break;
|
|
case '!':
|
|
case '>':
|
|
endian_found = Endian.bigEndian;
|
|
current_pos++;
|
|
endian_explicit = true;
|
|
break;
|
|
default:
|
|
}
|
|
|
|
// Get size
|
|
bool set_size = false;
|
|
size_t size = 0;
|
|
while ((current_pos < data.length) && ('0' <= data[current_pos]) && (data[current_pos] <= '9'))
|
|
{
|
|
set_size = true;
|
|
size = (size * 10) + (data[current_pos] - '0');
|
|
current_pos++;
|
|
}
|
|
if (!set_size)
|
|
{
|
|
size = 1;
|
|
}
|
|
|
|
// Get format
|
|
assert(current_pos + 1 == data.length, "Format '" ~ data[current_pos .. $] ~ "' isn't a valid format type.");
|
|
FORMAT_TYPE format_type_found;
|
|
switch (data[current_pos])
|
|
{
|
|
case 'b':
|
|
format_type_found = FORMAT_TYPE.INT_8;
|
|
current_pos++;
|
|
break;
|
|
case 'B':
|
|
format_type_found = FORMAT_TYPE.UINT_8;
|
|
current_pos++;
|
|
break;
|
|
case 'h':
|
|
format_type_found = FORMAT_TYPE.INT_16;
|
|
current_pos++;
|
|
break;
|
|
case 'H':
|
|
format_type_found = FORMAT_TYPE.UINT_16;
|
|
current_pos++;
|
|
break;
|
|
case 'i':
|
|
format_type_found = FORMAT_TYPE.INT_32;
|
|
current_pos++;
|
|
break;
|
|
case 'I':
|
|
format_type_found = FORMAT_TYPE.UINT_32;
|
|
current_pos++;
|
|
break;
|
|
case 'q':
|
|
format_type_found = FORMAT_TYPE.INT_64;
|
|
current_pos++;
|
|
break;
|
|
case 'Q':
|
|
format_type_found = FORMAT_TYPE.UINT_64;
|
|
current_pos++;
|
|
break;
|
|
case 's':
|
|
assert(set_size, "Size have to be set for the string.");
|
|
format_type_found = FORMAT_TYPE.STRING;
|
|
current_pos++;
|
|
break;
|
|
default:
|
|
assert(false, "Unknown format string: '" ~ data[current_pos .. $] ~ "'");
|
|
}
|
|
|
|
// TODO: Warn if endian isn't set explicit
|
|
|
|
// Return new struct
|
|
assert(current_pos == data.length);
|
|
Element result = {endian: endian_found, is_array: set_size, array_size: size, format_type: format_type_found};
|
|
return result;
|
|
}
|
|
}
|
|
|
|
template GET_TYPE(Element ELEMENT)
|
|
{
|
|
static if (ELEEMENT.format_type == FORMAT_TYPE.STRING)
|
|
{
|
|
alias GET_TYPE = string;
|
|
}
|
|
else
|
|
{
|
|
static assert(false);
|
|
}
|
|
}
|
|
|
|
/++
|
|
+ Removes the whitespaces of the string.
|
|
+ Params:
|
|
+ source = The source string to format
|
|
+ Returns: String without whitespaces
|
|
+/
|
|
pure string remove_whitespaces(string source)
|
|
{
|
|
return source.replace(" ", "");
|
|
}
|
|
|
|
pure Element[] parse_string(string source)
|
|
{
|
|
// Remove whitespaces
|
|
source = remove_whitespaces(source);
|
|
|
|
// Split after char
|
|
Element[] elements = [];
|
|
size_t pos = 0;
|
|
size_t last = 0;
|
|
while (pos < source.length)
|
|
{
|
|
if ((source[pos] >= 'a' && source[pos] <= 'z') || (source[pos] >= 'A' && source[pos] <= 'Z'))
|
|
{
|
|
elements ~= [Element.genFromString(source[last .. pos + 1])];
|
|
last = pos + 1;
|
|
}
|
|
pos++;
|
|
}
|
|
assert(last == pos, "Format doesn't end correctly.");
|
|
return elements;
|
|
}
|
|
|
|
// Test remove whitespaces.
|
|
unittest
|
|
{
|
|
assert(remove_whitespaces(" a b c ") == "abc");
|
|
}
|
|
|
|
// Test endian and length
|
|
unittest
|
|
{
|
|
{
|
|
const auto tmp = Element.genFromString("i");
|
|
assert(tmp.endian == endian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("=i");
|
|
assert(tmp.endian == endian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString(">i");
|
|
assert(tmp.endian == Endian.bigEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("!i");
|
|
assert(tmp.endian == Endian.bigEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<i");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<1i");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == true);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<11i");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == true);
|
|
assert(tmp.array_size == 11);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<111i");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == true);
|
|
assert(tmp.array_size == 111);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
}
|
|
|
|
// Test types parse
|
|
unittest
|
|
{
|
|
{
|
|
const auto tmp = Element.genFromString("<b");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_8);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<B");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.UINT_8);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<h");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_16);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<H");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.UINT_16);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<i");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<I");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.UINT_32);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<q");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.INT_64);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<Q");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == false);
|
|
assert(tmp.array_size == 1);
|
|
assert(tmp.format_type == FORMAT_TYPE.UINT_64);
|
|
}
|
|
{
|
|
const auto tmp = Element.genFromString("<10s");
|
|
assert(tmp.endian == Endian.littleEndian);
|
|
assert(tmp.is_array == true);
|
|
assert(tmp.array_size == 10);
|
|
assert(tmp.format_type == FORMAT_TYPE.STRING);
|
|
}
|
|
assertThrown!AssertError(Element.genFromString("s"));
|
|
assertThrown!AssertError(Element.genFromString("Z"));
|
|
}
|
|
|
|
// Test parse string
|
|
unittest
|
|
{
|
|
{
|
|
const auto tmp = parse_string("<16i>16i=16i!16i");
|
|
foreach (i; tmp)
|
|
{
|
|
assert(i.is_array == true);
|
|
assert(i.array_size == 16);
|
|
assert(i.format_type == FORMAT_TYPE.INT_32);
|
|
}
|
|
}
|
|
assertThrown!AssertError(parse_string("i16"));
|
|
assertThrown!AssertError(parse_string("i!"));
|
|
assertThrown!AssertError(parse_string("16!i"));
|
|
}
|
|
}
|
|
|
|
public
|
|
{
|
|
/++
|
|
+ Base format type
|
|
+/
|
|
struct BaseFormat(string CONFIG)
|
|
{
|
|
private
|
|
{
|
|
static const(Element[]) elements = parse_string(CONFIG);
|
|
static const(size_t) elements_size = {
|
|
size_t size = 0;
|
|
static foreach (i; elements)
|
|
{
|
|
size += i.packSize();
|
|
}
|
|
return size;
|
|
}();
|
|
}
|
|
|
|
public
|
|
{
|
|
/++
|
|
+ Calculate the size of the format.
|
|
+ Returns: Size of the format
|
|
+/
|
|
static size_t size()
|
|
{
|
|
return elements_size;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private
|
|
{
|
|
size_t test_size(string FORMAT)()
|
|
{
|
|
size_t result = BaseFormat!FORMAT.size();
|
|
{
|
|
auto tmp = parse_string(FORMAT);
|
|
size_t calced = 0;
|
|
foreach (i; tmp)
|
|
{
|
|
calced += i.packSize();
|
|
}
|
|
assert(result == calced);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
unittest
|
|
{
|
|
assert(test_size!"10s"() == 10);
|
|
assert(test_size!"b"() == 1);
|
|
assert(test_size!"4b"() == 4);
|
|
assert(test_size!"B"() == 1);
|
|
assert(test_size!"4B"() == 4);
|
|
assert(test_size!"h"() == 2);
|
|
assert(test_size!"4h"() == 8);
|
|
assert(test_size!"H"() == 2);
|
|
assert(test_size!"4H"() == 8);
|
|
assert(test_size!"i"() == 4);
|
|
assert(test_size!"4i"() == 16);
|
|
assert(test_size!"I"() == 4);
|
|
assert(test_size!"4I"() == 16);
|
|
assert(test_size!"q"() == 8);
|
|
assert(test_size!"4q"() == 32);
|
|
assert(test_size!"Q"() == 8);
|
|
assert(test_size!"4Q"() == 32);
|
|
}
|
|
}
|