Changeset 51

Timestamp:

06/26/08 16:35:27 (2 months ago)

Author:

baxissimo

Message:

First rev of the BinaryArchive?.
Main problem left to solve is how to handle platform-specific types like size_t (aka the diff between 32bit vs 64bit platforms) and the different flavors of real which are 80bits on intel with DMD, but 64 bits with GDC, I think.
Endian-ness is handled, but for now writing is always done in native-endian format.

Files:

• trunk/doost/util/serializer/Binary.d (added)
• trunk/doost/util/serializer/Serializer.d (modified) (1 diff)
• trunk/doost/util/serializer/archive/BinaryArchive.d (added)
• trunk/dsss.conf (modified) (1 diff)
• trunk/examples/util/serializer/FunctionTest.d (modified) (4 diffs)
• trunk/examples/util/serializer/dsss.conf (added)

trunk/doost/util/serializer/Serializer.d

@@ -212 +212 @@
-        this() {
-            registry = new Registry;
+            static if(is(typeof(init()))) {
+                bool ret = init();
+                if (!ret) {
+                    throw new SerializerException("Could not init archiver");
+                }
+            }
-        }
-

trunk/dsss.conf

@@ -1 @@
-
-
-
-
-
+
+
+

trunk/examples/util/serializer/FunctionTest.d

@@ -13 +13 @@
-
- ******************************************************************************/
+module FunctionTest;
-
-import std.traits;
@@ -24 +25 @@
-import doost.util.serializer.archive.TextArchive;
-import doost.util.serializer.archive.JsonArchive;
+import doost.util.serializer.archive.BinaryArchive;
-import doost.text.Scanner;
-
@@ -327 +329 @@
-//Serializer!(JsonArchive, dstring) jsondserializer;
-Serializer!(JsonArchiveExt) jsonextserializer;
+Serializer!(BinaryArchive, ubyte[]) binserializer;
-
-static this() {
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-}
-
@@ -1730 +1734 @@
-//------------------------------------------------------------------------------
-
+//------------------------------------------------------------------------------
+
+unittest {
+    testGroup.begin("Binary Archive");
+}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - string/wstring/dstring", {
+    string input;
+    ubyte[] output;
+    wstring winput;
+    dstring dinput;
+
+
+    input  = "pójdźŌe, kiń tę chmurność w głÄ
+b flaszy!";
+    winput  = "pójdźŌe, kiń tę chmurność w głÄ
+b flaszy!"w;
+    dinput  = "pójdźŌe, kiń tę chmurność w głÄ
+b flaszy!"d;
+    output = binserializer.dump(input);
+    trace(output);
+    assert(binserializer.load!(string)(output) == input);
+    output = binserializer.dump(winput);
+    trace(output);
+    assert(binserializer.load!(wstring)(output) == winput);
+    output = binserializer.dump(dinput);
+    trace(output);
+    assert(binserializer.load!(dstring)(output) == dinput);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - bool", {
+    bool input;
+    ubyte[] output;
+
+    input = true;
+    output = binserializer.dump(input);
+    assert(binserializer.load!(bool)(output) == input);
+
+    input = false;
+    output = binserializer.dump(input);
+    assert(binserializer.load!(bool)(output) == input);
+});}
+
+////------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - char", {
+    char input;
+    ubyte[] output;
+
+    input = 'a';
+    output = binserializer.dump(input);
+    assert(binserializer.load!(char)(output) == input);
+
+    input = 'A';
+    output = binserializer.dump(input);
+    assert(binserializer.load!(char)(output) == input);
+});}
+
+//------------------------------------------------------------------------------
+
+import std.stdio;
+unittest { testCase.execute("load/dump - atomic types", {
+    int input_int;
+    uint input_uint;
+    float input_float;
+    cfloat input_cfloat;
+    real input_real;
+    creal input_creal;
+    ireal input_ireal;
+
+    ubyte[] output;
+
+    input_int = -15;
+    output = binserializer.dump(input_int);
+    assert(binserializer.load!(int)(output) == input_int);
+
+    input_uint = 1774;
+    output = binserializer.dump(input_uint);
+    assert(binserializer.load!(uint)(output) == input_uint);
+
+    input_float = 1.123;
+    output = binserializer.dump(input_float);
+    assert(binserializer.load!(float)(output) == input_float);
+
+    input_real = 3.14159_26535_89793_23846_26433_83279_50288_41971_69399;
+    output = binserializer.dump(input_real);
+    assert(binserializer.load!(real)(output) == input_real);
+
+    input_cfloat = 1774 + 12.fi;
+    output = binserializer.dump(input_cfloat);
+    assert(binserializer.load!(cfloat)(output) == input_cfloat);
+
+    input_creal = 1774 + 12i;
+    output = binserializer.dump(input_creal);
+    assert(binserializer.load!(creal)(output) == input_creal);
+
+    input_ireal = 1774i;
+    output = binserializer.dump(input_ireal);
+    assert(binserializer.load!(ireal)(output) == input_ireal);
+});}
+
+//------------------------------------------------------------------------------
+unittest { testCase.execute("load/dump - int arrays", {
+    int[] input_int1;
+    int[][] input_int2;
+    int[][][] input_int3;
+    OpaqueClass[] input_class1;
+    TransparentClass[] input_class2;
+    OpaqueStruct[] input_struct1;
+
+    ubyte[] output;
+
+    input_int1 = [-1,45,34,-100,34];
+    output = binserializer.dump(input_int1);
+    trace(output);
+    //trace(binserializer.load!(int[])(output));
+    assert(binserializer.load!(int[])(output) == input_int1);
+
+
+    input_int2 = [[], [], []];
+    output = binserializer.dump(input_int2);
+    assert(binserializer.load!(int[][])(output) == input_int2);
+
+
+    input_int3 = [[[2,3],[4,5],[6,7]], [[]], [[0,-5],[-8,1]]];
+    output = binserializer.dump(input_int3);
+    assert(binserializer.load!(int[][][])(output) == input_int3);
+
+
+    //BUG: low precision: -5642.2321 would be wrong value
+    auto oc1 = new OpaqueClass(-567, float.nan, "class1", 22, -43);
+    auto oc2 = new OpaqueClass(234, 0.11, "class2", 28, -27);
+    auto oc3 = new OpaqueClass(2121, -4.00, "class1", 0, 21);
+    input_class1 = [oc1, oc2, oc3, null, null, oc1, oc1];
+    output = binserializer.dump(input_class1);
+    trace(output);
+    auto pom = binserializer.load!(OpaqueClass[])(output);
+    trace(binserializer.dump(pom));
+    assert(compareArrays(binserializer.load!(OpaqueClass[])(output), input_class1));
+
+    auto tc1 = new TransparentClass(-567, -5642.23, "class1", 22, -43);
+    auto tc2 = new TransparentClass(2121, -4.00, "class2", 0, 21);
+
+    input_class2 = [tc1, null, tc2];
+    output = binserializer.dump(input_class2);
+    trace(output);
+    assert(compareArrays(binserializer.load!(TransparentClass[])(output), input_class2));
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - class arrays", {
+    OpaqueClass[] input_class1;
+    TransparentClass[] input_class2;
+    OpaqueStruct[] input_struct1;
+
+    ubyte[] output;
+
+    //BUG: low precision: -5642.2321 would be wrong value
+    auto oc1 = new OpaqueClass(-567, -5642.23, "class1", 22, -43);
+    auto oc2 = new OpaqueClass(234, 0.11, "class2", 28, -27);
+    auto oc3 = new OpaqueClass(2121, -4.00, "class1", 0, 21);
+    input_class1 = [oc1, oc2, oc3, null, null, oc1, oc1];
+    output = binserializer.dump(input_class1);
+    trace(output);
+    //TODO: zmienić nazwę z compareArrays
+    assert(compareArrays(binserializer.load!(OpaqueClass[])(output), input_class1));
+
+    auto tc1 = new TransparentClass(-567, -5642.23, "class1", 22, -43);
+    auto tc2 = new TransparentClass(2121, -4.00, "class2", 0, 21);
+
+    input_class2 = [tc1, null, tc2];
+    output = binserializer.dump(input_class2);
+    trace(output);
+    assert(compareArrays(binserializer.load!(TransparentClass[])(output), input_class2));
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - static arrays", {
+    string[6] input_string;
+    real[3] input_real;
+    int[4] input_int;
+    TransparentComposedStruct[3] input_cstruct;
+    OpaqueComposedStruct[3] input_ocstruct;
+
+    ubyte[] output;
+
+    input_int[0]=5; input_int[1]=10; input_int[2]=15; input_int[3]=20;
+    output = binserializer.dump(input_int);
+    assert(binserializer.load!(int[5])(output) == input_int);
+
+    input_string[0]="Raz"; input_string[1]="Dwa"; input_string[2]="Trzy";
+    input_string[3]="Cztery"; input_string[4]="Pięć"; input_string[5]="Sześć";
+    output = binserializer.dump(input_string);
+    assert(binserializer.load!(string[6])(output) == input_string);
+
+    input_real[0]=3.14; input_real[0]=2.01; input_real[0]=-15.76;
+    output = binserializer.dump(input_real);
+    assert(binserializer.load!(real[6])(output) == input_real);
+
+    input_cstruct[0]=TransparentComposedStruct([1,2,3,4,5]);
+    input_cstruct[1]=TransparentComposedStruct([-100, -99, -98, -97, 0]);
+    input_cstruct[2]=TransparentComposedStruct([1,22,333,4444,55555]);
+    output = binserializer.dump(input_cstruct);
+    assert(binserializer.load!(TransparentComposedStruct[3])(output) == input_cstruct);
+
+    input_ocstruct[0]=OpaqueComposedStruct([6,7,8,9,10]);
+    input_ocstruct[1]=OpaqueComposedStruct([-1000, +900, -800, +700, 0]);
+    input_ocstruct[2]=OpaqueComposedStruct([-1,-22,-333,-4444,-55555]);
+    output = binserializer.dump(input_ocstruct);
+    assert(binserializer.load!(OpaqueComposedStruct[3])(output) == input_ocstruct);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - associative arrays", {
+    char[][int] input, result;
+    ubyte[] output;
+
+    input = [1 : "Maciek"[], 2 : "Paweł", 45 : "Renata"];
+    output = binserializer.dump(input);
+    result = binserializer.load!(char[][int])(output);
+    assert(result.keys == [1,2,45]);
+    assert(result.values == ["Maciek"[], "Paweł", "Renata"]);
+    //assert(result == input_1);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - transparent classes", {
+    TransparentClass input;
+    ubyte[] output;
+
+    input = new TransparentClass(-21, 2.11, "text1", 128, -127);
+    output = binserializer.dump(input);
+    assert(binserializer.load!(TransparentClass)(output) == input);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - opaque classes", {
+    OpaqueClass input;
+    ubyte[] output;
+
+    input = new OpaqueClass(-21, 2.11, "text1", 128, -127);
+    output = binserializer.dump(input);
+    assert(binserializer.load!(OpaqueClass)(output) == input);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - transparent structs", {
+    TransparentStruct input;
+    ubyte[] output;
+
+    input = TransparentStruct(-21, 2.11, "text1");
+    output = binserializer.dump(input);
+    assert(binserializer.load!(TransparentStruct)(output) == input);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - opaque structs", {
+    OpaqueStruct input;
+    ubyte[] output;
+
+    input = OpaqueStruct(-21, 2.11, "text1");
+    output = binserializer.dump(input);
+    trace(output);
+    assert(binserializer.load!(OpaqueStruct)(output) == input);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - typedefs", {
+    typedef int MyInt;
+    typedef string MyString;
+    typedef OpaqueStruct OS;
+    typedef OpaqueClass OC;
+
+    MyInt input_int;
+    MyString input_string;
+    OS input_struct;
+    OC input_class;
+
+    ubyte[] output;
+
+    input_int = 45;
+    output = binserializer.dump(input_int);
+    assert(binserializer.load!(MyInt)(output) == input_int);
+
+    input_string = cast(MyString)"my string".dup;
+    output = binserializer.dump(input_string);
+    assert(binserializer.load!(MyString)(output) == input_string);
+
+    input_struct = OS(-21, 2.11, "text1");;
+    output = binserializer.dump(input_struct);
+    assert(binserializer.load!(OS)(output) == input_struct);
+
+    input_class = cast(OC) new OpaqueClass(-21, 2.11, "text1", 23,98);
+    output = binserializer.dump(input_class);
+    //BUG: dmd hangs here...
+    //assert(binserializer.load!(OC)(output) == input_class);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - pointers", {
+    OpaqueStruct* input_struct;
+    OpaqueClass input_class;
+    OpaqueClass* p;
+    int*[] input_pint;
+    ubyte[] output;
+    int[4] ints = [23, 56, 89, 76];
+    int**[] input_ppint;
+
+
+    input_pint = [&ints[0], &ints[1], null, &ints[2], &ints[3], &ints[1], &ints[2], &ints[1]];
+    output = binserializer.dump(input_pint);
+    trace(output);
+
+    foreach(i, v; binserializer.load!(int*[])(output)) {
+        if (v is null || input_pint[i] is null) {
+            //trace("Values: ", v, " == ", input_pint[i]);
+            assert(v is input_pint[i]);
+            continue;
+        }
+        //trace("Values: ", *v, " == ", *input_pint[i]);
+        assert(*v == *input_pint[i]);
+    }
+
+    input_ppint = [&input_pint[0], &input_pint[1], &input_pint[2], &input_pint[6], &input_pint[7]];
+    output = binserializer.dump(input_ppint);
+    trace(output);
+    foreach(i, v; binserializer.load!(int**[])(output)) {
+        if (v is null || input_ppint[i] is null) {
+            trace("Values: ", v, " == ", input_ppint[i]);
+            assert(v is input_ppint[i]);
+            continue;
+        }
+
+        if (*v is null || *input_ppint[i] is null) {
+            trace("Values: ", *v, " == ", *input_ppint[i]);
+            assert(*v is *input_ppint[i]);
+            continue;
+        }
+
+        trace("Values: ", **v, " == ", **input_ppint[i]);
+        assert(**v == **input_ppint[i]);
+    }
+
+    input_struct = &OpaqueStruct(-21, 2.11, "text1");
+    output = binserializer.dump(input_struct);
+    trace(output);
+    assert(*binserializer.load!(OpaqueStruct*)(output) == *input_struct);
+
+    input_class = new OpaqueClass(-123, 0, "opaque class", 64, 0);
+    p = &input_class;
+    output = binserializer.dump(p);
+    trace(output);
+    assert(*binserializer.load!(OpaqueClass*)(output) == input_class);
+
+    //TODO: sprawdzić czy dobrze zachowujÄ
+ się takie typy jak Class****
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - tracking", {
+    binserializer.global().tracking = Tracking.OFF;
+
+    OpaqueStruct* input_struct;
+    int*[] input_pint;
+    ubyte[] output;
+    int[4] ints = [23, 56, 89, 76];
+
+    input_pint = [&ints[0], &ints[1], null, &ints[2], &ints[3], &ints[1], &ints[2], &ints[1]];
+    output = binserializer.dump(input_pint);
+
+    foreach(i, v; binserializer.load!(int*[])(output)) {
+        if (v is null || input_pint[i] is null) {
+            trace("Values: ", v, " == ", input_pint[i]);
+            assert(v is input_pint[i]);
+            continue;
+        }
+        trace("Values: ", *v, " == ", *input_pint[i]);
+        assert(*v == *input_pint[i]);
+    }
+
+    input_struct = &OpaqueStruct(-21, 2.11, "text1");
+    output = binserializer.dump(input_struct);
+    trace(output);
+    assert(*binserializer.load!(OpaqueStruct*)(output) == *input_struct);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - classes with methods load/dump", {
+    auto input = new TransparentWithLoadDump;
+    ubyte[] output;
+
+    input.login = "marcin"; input.password = "gÅŒegŌółka";
+    output = binserializer.dump(input);
+    trace(output);
+    trace(binserializer.load!(TransparentWithLoadDump)(output));
+    assert(binserializer.load!(TransparentWithLoadDump)(output) == input);
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - non default class constructor", {
+    NonDefaultConstructor input;
+    ubyte[] output;
+
+    binserializer.global().typeDescription!(NonDefaultConstructor).ctor = delegate NonDefaultConstructor () {
+        return new NonDefaultConstructor("Some string", 65);
+    };
+
+    input = new NonDefaultConstructor("Some string", 65);
+    input.a = "Other string";
+    input.b = 66;
+    output = binserializer.dump(input);
+    assert(binserializer.load!(NonDefaultConstructor)(output) == input);
+
+    //TODO: add also possibility to create structs; currently it's not necessary
+    //but when structs will have constructors...
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - struct/class versioning", {
+    VersionedClass_v1 input;
+    ubyte[] output;
+
+    //It is possible to do below; version property defined in below way
+    //is more important than defined in class itself.
+    //binserializer.global().typeDescription!(VersionedClass_v1).ver = 1;
+
+    input = new VersionedClass_v1; input.a = "Text"; input.b = 12;
+    output = binserializer.dump(input);
+    assert(binserializer.load!(VersionedClass_v1)(output) == input);
+
+/+
+    assert(binserializer.load!(VersionedClass_v1)("[\"Text\", 12]") == input);
+    assert(checkAssert({ binserializer.load!(VersionedClass_v1)("(0)[\"Text\", 12]");}) );
+    assert(binserializer.load!(VersionedClass_v1)("(1)[\"Text\", 12]") == input);
+    assert(checkException!(Exception)({binserializer.load!(VersionedClass_v1)("(2)[\"Text\", 12]");}));
+    assert(checkException!(Exception)({binserializer.load!(VersionedClass_v1)("(-1)[\"Text\", 12]");}));
++/
+});}
+
+//------------------------------------------------------------------------------
+
+unittest { testCase.execute("load/dump - versioned struct/class import", {
+    VersionedClass_v2 input;
+    ubyte[] output;
+
+    //BUG: doesn't work without () near global:
+    //binserializer.global().typeDescription!(VersionedClass2).ver = 2;
+
+    input = new VersionedClass_v2; input.a = "Text"; input.b = 12; input.c = "Import"; input.d=true;
+    output = binserializer.dump(input);
+    assert(binserializer.load!(VersionedClass_v2)(output) == input);
+/+
+    assert(checkException!(Exception)({binserializer.load!(VersionedClass_v2)("[\"Text\"]");}));
+    assert(binserializer.load!(VersionedClass_v2)("(2)[\"Text\", 12, \"Import\", true]") == input);
+    assert(binserializer.load!(VersionedClass_v2)("(1)[\"Text\", 12]") == input);
++/
+    //TODO: dodatkowe testy zachowania się gdy jest zdefniowany globalna wersja
+    //oraz w klasie - globalna powinna mieć pierwszeństwo
+});}
+
+//------------------------------------------------------------------------------
+/+
+TODO: Custom loaders/dumpers don't work with binary
+unittest { testCase.execute("load/dump - custom loaders/dumpers", {
+    MyClass input;
+    ubyte[] output;
+
+    binserializer.global().typeDescription!(MyClass).loader =
+        delegate bool (ref MyClass value, binserializer.Archive archive) {
+            value = new MyClass;
+
+            void check(bool res) {
+                if (!res) throw new Exception("Format for my class is not correct!");
+            }
+
+            skip(archive.storage, archive.defSkip.p_skip);
+            check(archive.traverse(value.x));
+            check(skip(archive.storage, "-") != 0);
+            check(archive.traverse(value.y));
+            check(skip(archive.storage, "-") != 0);
+            check(archive.traverse(value.z));
+
+            //TODO: rethink visibility of methods; e.g. traverse to Archive??
+            return true;
+        };
+
+    binserializer.global().typeDescription!(MyClass).dumper =
+        delegate bool (ref MyClass value, binserializer.Archive archive) {
+            archive.storage.put(format("%d-%d-%d", value.x, value.y, value.z));
+            return true;
+        };
+
+    input = new MyClass; input.x = 5; input.y = 10; input.z = 15;
+    output = binserializer.dump(input);
+    trace(output);
+    assert(output == "5-10-15");
+    assert(binserializer.load!(MyClass)(output) == input);
+});}
++/
+
+
+
-unittest {
-    testSuite.finish;