HashTableNT: deal with byte_order separately

the first value_format namedtuple element value should not be
special by including the byte order there, especially since that
byte order will apply to ALL elements.

So have it separately and prepend it to the joined elements formats.

src/borghash/HashTableNT.pxd

@@ -1,5 +1,6 @@
 cdef class HashTableNT:
     cdef int key_size
+    cdef object byte_order
     cdef object value_type
     cdef object value_format
     cdef object value_struct

src/borghash/HashTableNT.pyx

@@ -17,12 +17,14 @@ assert len(MAGIC) == 8
 VERSION = 1  # version of the on-disk (serialized) format produced by .write().
 HEADER_FMT = "<8sII"  # magic, version, meta length
 
+BYTE_ORDER = dict(big=">", little="<", network="!", native="=")  # struct format chars
+
 _NoDefault = object()
 
 cdef class HashTableNT:
     def __init__(self, items=None, *,
                  key_size: int, value_type: Any, value_format: Any,
-                 capacity: int = MIN_CAPACITY) -> None:
+                 capacity: int = MIN_CAPACITY, byte_order="little") -> None:
         if not isinstance(key_size, int) or not key_size > 0:
             raise ValueError("key_size must be an integer and > 0.")
         if type(value_type) is not type:
@@ -33,10 +35,13 @@ cdef class HashTableNT:
             raise TypeError("value_format's and value_type's element names must correspond.")
         if not all(isinstance(fmt, str) and len(fmt) > 0 for fmt in value_format):
             raise ValueError("value_format's elements must be str and non-empty.")
+        if byte_order not in BYTE_ORDER:
+            raise ValueError("byte_order must be one of: {','.join(BYTE_ORDER.keys())}")
         self.key_size = key_size
         self.value_type = value_type
         self.value_format = value_format
-        self.value_struct = struct.Struct("".join(value_format))
+        self.byte_order = byte_order
+        self.value_struct = struct.Struct(BYTE_ORDER[byte_order] + "".join(value_format))
         self.value_size = self.value_struct.size
         self.inner = HashTable(key_size=self.key_size, value_size=self.value_size, capacity=capacity)
         _fill(self, items)
@@ -164,6 +169,7 @@ cdef class HashTableNT:
         meta = {
             'key_size': self.key_size,
             'value_size': self.value_size,
+            'byte_order': self.byte_order,
             'value_type_name': self.value_type.__name__,
             'value_type_fields': self.value_type._fields,
             'value_format_name': self.value_format.__class__.__name__,
@@ -210,7 +216,8 @@ cdef class HashTableNT:
         value_type = namedtuple(meta['value_type_name'], meta['value_type_fields'])
         value_format_t = namedtuple(meta['value_format_name'], meta['value_format_fields'])
         value_format = value_format_t(*meta['value_format'])
-        ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type, capacity=meta['capacity'])
+        ht = cls(key_size=meta['key_size'], value_format=value_format, value_type=value_type,
+                 capacity=meta['capacity'], byte_order=meta['byte_order'])
         count = 0
         ksize, vsize = meta['key_size'], meta['value_size']
         for i in range(meta['used']):

src/borghash/__main__.py

@@ -16,7 +16,7 @@ def demo():
 count = 50000
 value_type = namedtuple("Chunk", ["refcount", "size"])
 value_format_t = namedtuple("ChunkFormat", ["refcount", "size"])
-value_format = value_format_t(refcount="<I", size="I")
+value_format = value_format_t(refcount="I", size="I")
 # 256bit (32Byte) key, 2x 32bit (4Byte) values
 ht = HashTableNT(key_size=32, value_type=value_type, value_format=value_format)
 

tests/benchmark_test.py

@@ -11,7 +11,7 @@
 
 VALUE_TYPE = namedtuple("value_type", "value")
 VALUE_FMT_TYPE = namedtuple("value_format", "value")
-VALUE_FMT = VALUE_FMT_TYPE("<I")
+VALUE_FMT = VALUE_FMT_TYPE("I")
 KEY_SIZE = len(H2(0))
 VALUE_SIZE = len(struct.pack("".join(VALUE_FMT), 0))
 VALUE_BITS = VALUE_SIZE * 8

tests/hashtablent_test.py

@@ -10,7 +10,7 @@
 key_size = 32  # 32 bytes = 256bits key
 value_type = namedtuple("vt", "v1 v2 v3")
 value_format_t = namedtuple("vf", "v1 v2 v3")
-value_format = value_format_t(v1="<I", v2="I", v3="I")  # 3x little endian 32bit unsigned int
+value_format = value_format_t(v1="I", v2="I", v3="I")  # 3x little endian 32bit unsigned int
 
 key1, value1 = b"a" * 32, value_type(11, 12, 13)
 key2, value2 = b"b" * 32, value_type(21, 22, 23)