Merge lp:~ahayzen/htd/31.fix.1059893 into lp:htd/3.1

[Andrew Hayzen]

Data Types retain ordering

[Andrew Hayzen (ahayzen)]

review: Approve

=== modified file 'htd31/_base/types.py'
--- htd31/_base/types.py	2012-08-13 20:06:11 +0000
+++ htd31/_base/types.py	2012-10-03 20:46:22 +0000
@@ -35,6 +35,20 @@
 reg_dtype = Register.register_dtype  # Register dtypes
 
 
+if sys.version_info < (3, 0):
+    char = chr
+else:
+    def char(data):
+        return chr(int(data)).encode("ISO-8859-1")
+
+
+if sys.version_info < (3, 0):
+    ordi = ord
+else:
+    def ordi(raw):
+        return raw
+
+
 #--------------------------------------------------------------- Raw data types
 class BOOL(DType):
     idn = b"\x01"
@@ -167,80 +181,141 @@
 
 
 #------------------------------------------------------------ Number data types
-class NumBase(DType):
+class BYTE(DType):
     can_range = True
-
-    def sanitise(self, real):
-        return pack(self._c, real)
-
-    def unsanitise(self, raw):
-        return unpack(self._c, raw)[0]
-
-
-class BYTE(NumBase):
     idn = b"\x0f"
-    _c = "b"
-    can_range = True
     size = 1
 
+    def sanitise(self, real):
+        return char(real + 128)
+
     def type_check(self, real):
         return type(real) is int
 
-
-class UBYTE(NumBase):
+    def unsanitise(self, raw):
+        return ordi(raw) - 128
+
+
+class UBYTE(DType):
+    can_range = True
     idn = b"\x10"
-    _c = "B"
-    can_range = True
     size = 1
 
+    def sanitise(self, real):
+        return char(real)
+
     def type_check(self, real):
         return type(real) is int
 
-
-class SHORT(NumBase):
+    def unsanitise(self, raw):
+        return ordi(raw)
+
+
+class SHORT(DType):
+    can_range = True
     idn = b"\x11"
-    _c = "h"
-    can_range = True
     size = 2
 
+    def sanitise(self, real):
+        real += 32768
+
+        a, b = divmod(real, 256)
+
+        return b"".join([char(a), char(b)])
+
     def type_check(self, real):
         return type(real) is int
 
-
-class USHORT(NumBase):
+    def unsanitise(self, raw):
+        a, b = raw
+
+        return (ordi(a) * 256 + ordi(b)) - 32768
+
+
+class USHORT(DType):
+    can_range = True
     idn = b"\x12"
-    _c = "H"
-    can_range = True
     size = 2
 
+    def sanitise(self, real):
+        a, b = divmod(real, 256)
+
+        return b"".join([char(a), char(b)])
+
     def type_check(self, real):
         return type(real) is int
 
-
-class INTEGER(NumBase):
+    def unsanitise(self, raw):
+        a, b = raw
+
+        return (ordi(a) * 256) + ordi(b)
+
+
+class INTEGER():
+    can_range = True
     idn = b"\x13"
-    _c = "i"
-    can_range = True
     size = 4
 
+    def sanitise(self, real):
+        real += 2147483648
+
+        a, real = divmod(real, 256 ** 3)
+        b, real = divmod(real, 256 ** 2)
+        c, d = divmod(real, 256)
+
+        return b"".join([char(a), char(b), char(c), char(d)])
+
     def type_check(self, real):
         return type(real) is int
 
-
-class UINTEGER(NumBase):
+    def unsanitise(self, raw):
+        a, b, c, d = raw
+
+        return ((ordi(a) * 256 ** 3) + (ordi(b) * 256 ** 2) +
+                (ordi(c) * 256) + ordi(d) - 2147483648)
+
+
+class UINTEGER(DType):
+    can_range = True
     idn = b"\x14"
-    _c = "I"
     size = 4
 
+    def sanitise(self, real):
+        a, real = divmod(real, 256 ** 3)
+        b, real = divmod(real, 256 ** 2)
+        c, d = divmod(real, 256)
+
+        return b"".join([char(a), char(b), char(c), char(d)])
+
     def type_check(self, real):
         return type(real) is int
 
-
-class LONG(NumBase):
+    def unsanitise(self, raw):
+        a, b, c, d = raw
+
+        return ((ordi(a) * 256 ** 3) + (ordi(b) * 256 ** 2) +
+                (ordi(c) * 256) + d)
+
+
+class LONG():
+    can_range = True
     idn = b"\x15"
-    _c = "q"
     size = 8
 
+    def sanitise(self, real):
+        real += 9223372036854775808
+
+        a, real = divmod(real, 256 ** 7)
+        b, real = divmod(real, 256 ** 6)
+        c, real = divmod(real, 256 ** 5)
+        d, real = divmod(real, 256 ** 4)
+        e, real = divmod(real, 256 ** 3)
+        f, real = divmod(real, 256 ** 2)
+        g, h = divmod(real, 256)
+
+        return b"".join([char(a), char(b), char(c), char(d), char(e), char(f),
+                         char(g), char(h)])
+
     if sys.version_info < (3, 0):
         def type_check(self, real):
             return type(real) is long
@@ -248,12 +323,32 @@
         def type_check(self, real):
             return type(real) is int
 
-
-class ULONG(NumBase):
+    def unsanitise(self, raw):
+        a, b, c, d, e, f, g, h = raw
+
+        return ((ordi(a) * 256 ** 7) + (ordi(b) * 256 ** 6) +
+                (ordi(c) * 256 ** 5) + (ordi(d) * 256 ** 4) +
+                (ordi(e) * 256 ** 3) + (ordi(f) * 256 ** 2) +
+                (ordi(g) * 256) + ordi(h)) - 9223372036854775808
+
+
+class ULONG():
+    can_range = True
     idn = b"\x16"
-    _c = "Q"
     size = 8
 
+    def sanitise(self, real):
+        a, real = divmod(real, 256 ** 7)
+        b, real = divmod(real, 256 ** 6)
+        c, real = divmod(real, 256 ** 5)
+        d, real = divmod(real, 256 ** 4)
+        e, real = divmod(real, 256 ** 3)
+        f, real = divmod(real, 256 ** 2)
+        g, h = divmod(real, 256)
+
+        return b"".join([char(a), char(b), char(c), char(d), char(e), char(f),
+                         char(g), char(h)])
+
     if sys.version_info < (3, 0):
         def type_check(self, real):
             return type(real) is long
@@ -261,24 +356,180 @@
         def type_check(self, real):
             return type(real) is int
 
-
-class FLOAT(NumBase):
+    def unsanitise(self, raw):
+        a, b, c, d, e, f, g, h = raw
+
+        return ((ordi(a) * 256 ** 7) + (ordi(b) * 256 ** 6) +
+                (ordi(c) * 256 ** 5) + (ordi(d) * 256 ** 4) +
+                (ordi(e) * 256 ** 3) + (ordi(f) * 256 ** 2) +
+                (ordi(g) * 256) + ordi(h))
+
+
+#------------------------------------------------------- Float helper functions
+def float_sanitise(real):
+    raw = str(abs(real))
+
+    if "e" in raw:
+        raw, ex = raw.split("e")
+        ex = char(int(ex) + 127)
+    else:
+        ex = False
+
+    if "." in raw:
+        ex = 0
+        d = False
+
+        for i in raw:
+            if i not in ["0", "."]:
+                d = True
+
+            if i != "." and d:
+                ex += 1
+
+            if (i == "." or ex < 0) and d:
+                break
+
+            if i in [".", "0"] and not d:
+                ex -= 1
+
+        if real < 0:
+            if ex < 0:
+                ex = 255 + ex
+            else:
+                ex = 127 - ex
+        else:
+            ex += 127
+
+        ex = char(ex)
+        w, d = raw.split(".")
+    else:
+        w = raw
+        d = ""
+
+    n = "".join([w, d]).lstrip("0")[:9]
+    n = n.ljust(9, "0")
+    n = int(n)
+
+    # Convert to negative offset
+    if real < 0:
+        n = -n
+        neg = b"\x00"
+    else:
+        neg = b"\x01"
+
+    return n, neg, ex
+
+
+def float_unsanitise(n, neg, ex):
+    # Calc exponent
+    if neg == 0:
+        if ex > 128:
+            ex -= 255
+        else:
+            ex = 127 - ex
+    else:
+        ex -= 127
+
+    n = list(str(n))
+
+    # Build exp and data
+    if neg == 0:
+        off = 1
+    else:
+        off = 0
+
+    if ex < 0:
+        for _ in range(0, abs(ex)):
+            n.insert(off, "0")
+
+        n.insert(abs(ex) + off, ".")
+    elif ex > 0:
+        while len(n) + off < ex:
+            n.append("0")
+
+        n.insert(ex + off, ".")
+
+    return float("".join(n))
+
+
+class FLOAT(DType):
+    can_range = True
     idn = b"\x1e"
-    _c = "f"
-    size = 4
+    size = 6
+
+    def sanitise(self, real):
+        if real == 0.0:
+            return b"\x01\x00\x00\x00\x00\x00"
+
+        # Convert to raw int
+        n, neg, ex = float_sanitise(real)
+
+        # Convert to hex
+        n += 2147483648
+
+        a, n = divmod(n, 256 ** 3)
+        b, n = divmod(n, 256 ** 2)
+        c, d = divmod(n, 256)
+
+        return b"".join([neg, ex, char(a), char(b), char(c), char(d)])
 
     def type_check(self, real):
         return type(real) is float
 
-
-class DFLOAT(NumBase):
+    def unsanitise(self, raw):
+        if raw == b"\x01\x00\x00\x00\x00\x00":
+            return 0.0
+
+        neg, ex, a, b, c, d = raw
+
+        n = ((ordi(a) * 256 ** 3) + (ordi(b) * 256 ** 2) + (ordi(c) * 256) +
+             ordi(d) - 2147483648)
+
+        return float_unsanitise(n, ordi(neg), ordi(ex))
+
+
+class DFLOAT(DType):
+    can_range = True
     idn = b"\x1f"
-    _c = "d"
     size = 8
 
+    def sanitise(self, real):
+        if real == 0.0:
+            return b"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+
+        # Convert to raw int
+        n, neg, ex = float_sanitise(real)
+
+        # Convert to hex
+        n += 9223372036854775808
+
+        a, n = divmod(n, 256 ** 7)
+        b, n = divmod(n, 256 ** 6)
+        c, n = divmod(n, 256 ** 5)
+        d, n = divmod(n, 256 ** 4)
+        e, n = divmod(n, 256 ** 3)
+        f, n = divmod(n, 256 ** 2)
+        g, h = divmod(n, 256)
+
+        return b"".join([neg, ex, char(a), char(b), char(c), char(d), char(e),
+                         char(f), char(g), char(h)])
+
     def type_check(self, real):
         return type(real) is float
 
+    def unsanitise(self, raw):
+        if raw == b"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00":
+            return 0.0
+
+        neg, ex, a, b, c, d, e, f, g, h = raw
+
+        n = ((ordi(a) * 256 ** 7) + (ordi(b) * 256 ** 6) +
+             (ordi(c) * 256 ** 5) + (ordi(d) * 256 ** 4) +
+             (ordi(e) * 256 ** 3) + (ordi(f) * 256 ** 2) +
+             (ordi(g) * 256) + ordi(h)) - 9223372036854775808
+
+        return float_unsanitise(n, ordi(neg), ordi(ex))
+
 
 reg_dtype(BYTE)
 reg_dtype(UBYTE)
@@ -356,8 +607,8 @@
             x = getattr(DataType, Register.dtype_codes[ty])
             if isinstance(x, PRESERVE) is False and x.type_check(real):
                 try:
-                    tmp = b"".join([x.sanitise(real), ty])
-                except struct_error:
+                    tmp = b"".join([ty, x.sanitise(real)])
+                except (ValueError, OverflowError, struct_error):
                     continue
                 else:
                     return tmp
@@ -374,28 +625,16 @@
 
         return False
 
-    if sys.version_info < (3, 0):
-        def unsanitise(self, raw):
-            ty = raw[-1]
-            raw = raw[:-1]
-
-            if ty in Register.dtype_codes:
-                x = getattr(DataType, Register.dtype_codes[ty])
-            else:
-                raise TypeError("Could not restore type.")
-
-            return x.unsanitise(raw)
-    else:
-        def unsanitise(self, raw):
-            ty = chr(raw[-1]).encode("ISO-8859-1")
-            raw = raw[:-1]
-
-            if ty in Register.dtype_codes:
-                x = getattr(DataType, Register.dtype_codes[ty])
-            else:
-                raise TypeError("Could not restore type.")
-
-            return x.unsanitise(raw)
+    def unsanitise(self, raw):
+        ty = char(raw[0])
+        raw = raw[1:]
+
+        if ty in Register.dtype_codes:
+            x = getattr(DataType, Register.dtype_codes[ty])
+        else:
+            raise TypeError("Could not restore type.")
+
+        return x.unsanitise(raw)
 
 
 reg_dtype(PRESERVE)