Changeset 31

Timestamp:

01/29/08 18:20:30 (1 year ago)

Author:

aarti_pl

Message:

- json archive
- improved DUnit (tests updated)
- few refactorings in serializer
- Escaper throws on invalid escape sequence

Files:

• trunk/doost/core/Any.d (modified) (5 diffs)
• trunk/doost/text/Escaper.d (modified) (2 diffs)
• trunk/doost/util/DUnit.d (modified) (4 diffs)
• trunk/doost/util/serializer/Registry.d (modified) (1 diff)
• trunk/doost/util/serializer/Serializer.d (modified) (9 diffs)
• trunk/doost/util/serializer/archive/JSONArchive.d (added)
• trunk/doost/util/serializer/archive/TextArchive.d (modified) (29 diffs)
• trunk/examples/util/config/FunctionTest.d (modified) (24 diffs)
• trunk/examples/util/serializer/FunctionTest.d (modified) (38 diffs)
• trunk/examples/util/serializer/util_serializer.cbp (modified) (2 diffs)
• trunk/std2/contracts.d (added)
• trunk/std2/string.d (modified) (25 diffs)

trunk/doost/core/Any.d

@@ -213 +213 @@
-
-unittest {
-startSuite
+testSuite.begin
-}
-
@@ -227 +227 @@
-//------------------------------------------------------------------------------
-
-cas
+Case.execut
-    bool assigned=false;
-    auto t=new Test;
@@ -254 +254 @@
-//------------------------------------------------------------------------------
-
-cas
+Case.execut
-    auto v = Any();
-    auto z = Any();
@@ -267 +267 @@
-//------------------------------------------------------------------------------
-
-cas
+Case.execut
-    auto v = Any();
-    v=5;
@@ -279 +279 @@
-
-unittest {
-finishSuite
-
+testSuite.finish
+

trunk/doost/text/Escaper.d

@@ -8 +8 @@
-
-//TODO: add other escape sequences from: http://www.digitalmars.com/d/lex.html
+
+
+class UnescapeException : Exception {
+    this(string str) {
+        super(str);
+    }
+}
-
-/*******************************************************************************
@@ -57 +64 @@
-                case 't'  : result ~= '\t'; break;
-                case 'v'  : result ~= '\v'; break;
-result ~= c
+throw new UnescapeException("Illegal escape character")
-            }
-            isEscape=false;

trunk/doost/util/DUnit.d

@@ -23 +23 @@
-import std.date;
-import std2.traits;
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    string trace;
-    long line;
@@ -36 +225 @@
-}
-
-struct Failure {
-    string error;
-}
-
-//------------------------------------------------------------------------------
-
-string ctfe_repeat(string s, uint count) {
-    string result;
-    for(uint i=0; i<count; i++) result~=s;
-    return result;
-}
-
-string ctfe_ulongTostring(ulong value) {
-    string result;
-    ulong divider = 10_000_000_000_000_000_000UL;
-    while (divider>value) divider/=10;
-
-    do {
-        result ~= cast(char)value / divider + 48;
-        value -= (value / divider) * divider;
-    } while ((divider /= 10)!=0)
-
-    return result;
-}
-
-//------------------------------------------------------------------------------
-//TODO: pod linuxem nie moÅŒna złapać "segmentation fault", tylko program się wykłada
-
-//TODO: traces are not connected with failures; should be stored separately
-//posibility to show traces only on failure
-
-TestCase[uint] testcases;
-Trace[][uint] traces;
-Failure[uint] failed;
-
-uint tc_counter, tc_fcounter;
-void delegate() setUp, tearDown;
-d_time starttime, elapsedtime;
-
-
-const table_width = 70;
-const table_col1_width = 3;
-const table_col3_width = 6;
-const table_col2_width = table_width - table_col1_width - table_col3_width - 5;
-
-const table_hr = " " ~ ctfe_repeat("-", table_width-2) ~ " ";
-
-const table_simple = "|%-"~ ctfe_ulongTostring(table_width-2) ~"s|";
-const table_tc_col1 = "|%"~ ctfe_ulongTostring(table_col1_width) ~"d.";
-const table_tc_col2 = " %-"~ ctfe_ulongTostring(table_col2_width) ~"s";
-const table_tc_col3 = "%"~ ctfe_ulongTostring(table_col3_width) ~"s |";
-
-const table_stat_all  = "|  - all    : %-3d" ~ ctfe_repeat(" ", table_width-18) ~"|";
-const table_stat_pass = "|  - passed : %-3d (%6.2f%%)" ~ ctfe_repeat(" ", table_width-28) ~"|";
-const table_stat_fail = "|  - failed : %-3d (%6.2f%%)" ~ ctfe_repeat(" ", table_width-28) ~"|";
-
-const table_fail_row1 = "|%3d. %-"~ ctfe_ulongTostring(table_width-7) ~"s|";
-const table_fail_row2 = "|     %-"~ ctfe_ulongTostring(table_width-7) ~"s|";
-
-//TODO: lepsze funkcje do wydruku tabeli (bardziej uniwersalne)
-//moÅŒe wystarczy tylko usuwać z ciÄ
-gu formatujÄ
-cego wszystkie spacje? np.
-//wydruk nie tylko na ekran, ale takÅŒe do pliku + do kilku źródeł
-
-
-//  -----------------------------------------------
-// | * test suite...      | Status | Count | Time  |
-//  -----------------------------------------------
-// |*    |*               |       *|     * |   *   |
-//  -----------------------------------------------
-// | Traces:                                       |
-// |                                               |
-//  -----------------------------------------------
-
-//------------------------------------------------------------------------------
-
-//TODO: ewentualnie dodawanie setup i teardown w osobnych funkcjach, ale
-//TODO: co z wielowÄ
-tkowościÄ
-?
-
-void startSuite(char[] name, void delegate() setup=null, void delegate() teardown=null) {
-    failed = null;
-    tc_counter = 0;
-    tc_fcounter = 0;
-    setUp = setup;
-    tearDown = teardown;
-    writefln(table_hr);
-    writefln(table_simple, " " ~ name ~ " test suite.");
-    writefln(table_hr);
-}
-
-//TODO: add function startGroup/finishGroup
+
+//------------------------------------------------------------------------------
+
+class TestCase {
+public:
+    void execute(string testname, void delegate() dg) {
+        m_testname = testname;
+        m_passed = false;
+        m_elapsedtime = real.nan;
+
+        int no;
+        string result;
+
+        if (m_repeat != 0) {
+            no = m_repeat;
+            m_owner.m_tccounter++;
+            m_number = m_owner.m_tccounter;
+            try {
+                d_time starttime = getUTCtime();
+                for(uint i = 0; i<m_repeat; i++) {
+                    if (m_setup !is null) m_setup();
+                    dg();
+                    if (m_teardown !is null) m_teardown();
+                }
+                m_elapsedtime = (cast(real)(getUTCtime() - starttime))/1000;
+                result = "OK";
+                m_passed = true;
+            }
+            catch(Exception e) {
+                result = "FAIL";
+                m_error = e.toString;
+                m_owner.m_tcfcounter++;
+                m_owner.m_tcfailed~=this;
+                no = 0;
+            }
+        } else result = "DISABLED";
+
+        string tc_no;
+        if (m_repeat == 0) {tc_no = "-- "; no = 0; }
+            else tc_no = to!(string)(m_owner.m_tccounter) ~ ".";
+
+        if (m_dotiming) m_owner.table.render(m_owner.tc_tim, tc_no, m_testname ~ " test...", result, no, m_elapsedtime);
+            else m_owner.table.render(m_owner.tc, tc_no, m_testname ~ " test...", result);
+
+        if (m_elapsedtime !is real.nan) m_owner.m_elapsedtime+=m_elapsedtime;
+    }
+
+    TestCase setUp(void delegate() setup) {
+        m_setup = setup;
+        return this;
+    }
+
+    TestCase tearDown(void delegate() teardown) {
+        m_teardown = teardown;
+        return this;
+    }
+
+    TestCase repeat(uint count) {
+        m_repeat = count;
+        return this;
+    }
+
+    TestCase disable() {
+        m_repeat = 0;
+        return this;
+    }
+
+    TestCase traces() {
+        m_dotraces = true;
+        m_owner.m_reqtraces = true;
+        return this;
+    }
+
+private:
+    this(TestSuite owner) {
+        m_owner = owner;
+    }
+
+    void printTraces() {
+        string lastfile = "";
+        foreach(t; m_traces) {
+            if (t.file != lastfile) {
+                m_owner.table.render(m_owner.simple);
+                if (t.file != "") m_owner.table.render(m_owner.simple, "     " ~ getBaseName(t.file) ~ ":");
+                    else m_owner.table.render(m_owner.simple);
+                lastfile = t.file;
+            }
+
+            if (t.line !=0) m_owner.table.render(m_owner.simple, "     " ~ format("%4d:  %s", t.line, t.trace));
+                else m_owner.table.render(m_owner.simple, "     " ~ t.trace);
+        }
+    }
+
+
+    string m_testname;
+    uint m_repeat = 1;
+    void delegate() m_setup;
+    void delegate() m_teardown;
+
+    TraceInfo[] m_traces;
+    string m_error;
+    bool m_passed;
+    bool m_dotiming;
+    bool m_dotraces;
+
+    real m_elapsedtime;
+    uint m_number;
+    TestSuite m_owner;
+
+}
+
+//------------------------------------------------------------------------------
+
+class TestGroup {
+public:
+    void begin(string groupname="") {
+        m_groupname = groupname;
+        if (groupname != "") {
+            //m_owner.table.render(m_owner.simple);
+            /*if (!first)*/ m_owner.table.render(m_owner.hl);
+            m_owner.table.render(m_owner.simple, "Group: " ~ groupname);
+            /*if (!last)*/ //m_owner.table.render(m_owner.hl);
+        }
+    }
+
+    void finish() {
+
+    }
+
+    TestGroup setUp(void delegate() setup) {
+        m_setup = setup;
+        return this;
+    }
+
+    TestGroup tearDown(void delegate() teardown) {
+        m_teardown = teardown;
+        return this;
+    }
+
+    TestGroup repeat(uint count) {
+        m_repeat = count;
+        return this;
+    }
+
+    TestGroup disable() {
+        m_repeat = 0;
+        return this;
+    }
+
+private:
+    this(TestSuite owner) {
+        m_owner = owner;
+    }
+
+    string m_groupname;
+    uint m_repeat = 1;
+    void delegate() m_setup;
+    void delegate() m_teardown;
+    bool m_dotiming;
+    bool m_dotraces;
+
+    TestSuite m_owner;
+}
+
+//------------------------------------------------------------------------------
+
+class TestSuite {
+public:
+    //TODO: function disable, which sets repeat to 0
+    //TODO: tylko jeden otwarty test suite jednocześnie.
+    //jeÅŒeli ktoś próbuje otworzyć drugi to musi czekać na skończenie pierwszego??
+    //jeÅŒeli na tym samym threadzie, to po prostu błÄ
+d
+
+    void begin(string suitename) {
+        m_suitename = suitename;
+        m_tccounter = 0;
+        m_tcfcounter = 0;
+
+        table.render(hl);
+        table.render(title, m_suitename ~ " test suite.");
+        //table.render(hl);
+    }
+
+    void finish() {
+        uint tcpcounter = m_tccounter - m_tcfcounter;
+
+        if (m_tcfailed.length>0) {
+            table.render(hl);
+            table.render(simple, "Failed test cases / errors / traces:");
+            table.render(simple);
+            foreach(tc; m_tcfailed) {
+                table.render(fail, tc.m_number, tc.m_testname);
+                table.render(simple, "     " ~ tc.m_error);
+                table.render(simple);
+                tc.printTraces;
+            }
+
+        }
+
+        if (m_dotraces || m_reqtraces) {
+            table.render(hl);
+            table.render(simple, "Traces:");
+            table.render(simple);
+            foreach(tc; m_testcases) {
+                if (tc.m_repeat == 0 || tc.m_dotraces == false) continue;
+                table.render(fail, tc.m_number, tc.m_testname);
+                tc.printTraces;
+                table.render(simple);
+            }
+        }
+
+        table.render(hl);
+        table.render(simple);
+        table.render(etime,  "Statistics :", "Total time :", m_elapsedtime);
+        table.render(stat,  " -    all  :", m_tccounter);
+        table.render(stat,  " - passed  :", tcpcounter, cast(double)(tcpcounter*100)/m_tccounter);
+        table.render(stat,  " - failed  :", m_tcfcounter, cast(double)(m_tcfcounter*100)/m_tccounter);
+        table.render(hl);
+
+    }
+
+    TestSuite setUp(void delegate() setup) {
+        m_setup = setup;
+        return this;
+    }
+
+    TestSuite tearDown(void delegate() teardown) {
+        m_teardown = teardown;
+        return this;
+    }
+
+    TestSuite timing() {
+        m_dotiming = true;
+        return this;
+    }
+
+    TestSuite traces() {
+        m_dotraces = true;
+        return this;
+    }
+
+    TestSuite repeat(uint count) {
+        m_repeat = count;
+        return this;
+    }
+
+    TestSuite disable() {
+        m_repeat = 0;
+        return this;
+    }
+
+    TestSuite width(uint w) {
+        table.m_width = w;
+        return this;
+    }
+
+private:
+    /***************************************************************************
+        Private constructor to avoid creating suites from outside
+     **************************************************************************/
+    this() {
+        table = new Table;
+
+        title   = [Sep, Cell(-1, Align.Center), Sep];
+        tc      = [Sep, Cell(5, Align.Right, "%-s", 0), Cell(-1, Align.Left), Cell(7, Align.Right), Sep];
+        tc_tim  = [Sep, Cell(5, Align.Right, "%-s", 0), Cell(-1, Align.Left), Cell(7, Align.Right), Sep, Cell(8, Align.Right), Sep, Cell(8, Align.Right, "%6.2f"), Sep];
+        simple  = [Sep, Cell(-1, Align.Left), Sep];
+        etime   = [Sep, Cell(15, Align.Right), Cell(-1, Align.Right), Cell(10, Align.Left, "%6.4f s"), Sep];
+        stat    = [Sep, Cell(15, Align.Right), Cell(6, Align.Left), Cell(-1, Align.Left, "(%6.2f %%)"), Sep];
+        fail    = [Sep, Cell(5, Align.Right, "%d."), Cell(-1, Align.Left), Sep];
+        hl      = [Hl];
+
+    }
+
+    /***************************************************************************
+     **************************************************************************/
+    TestGroup createGroup() {
+        auto tg = new TestGroup(this);
+        tg.repeat(m_repeat);
+        tg.setUp(m_setup);
+        tg.tearDown(m_teardown);
+        tg.m_dotiming = m_dotiming;
+        tg.m_dotraces = m_dotraces;
+        m_testgroups~=tg;
+        m_curgroup = tg;
+        m_firstingroup = true;
+        return tg;
+    }
+
+    TestCase createCase() {
+        auto tc = new TestCase(this);
+        if (m_curgroup !is null) {
+            tc.repeat(m_curgroup.m_repeat);
+            tc.setUp(m_curgroup.m_setup);
+            tc.tearDown(m_curgroup.m_teardown);
+            tc.m_dotiming = m_curgroup.m_dotiming;
+            tc.m_dotraces = m_dotraces;
+        } else {
+            tc.repeat(m_repeat);
+            tc.setUp(m_setup);
+            tc.tearDown(m_teardown);
+            tc.m_dotiming = m_dotiming;
+            tc.m_dotraces = m_dotraces;
+        }
+
+        if (m_firstingroup) {table.render(hl); m_firstingroup=false;}
+        m_testcases~=tc;
+        m_curcase = tc;
+        return m_testcases[$-1];
+    }
+
+    Table table;
+    Row title, tc, tc_tim, simple, etime, stat, fail, hl;
+
+    void delegate() m_setup;
+    void delegate() m_teardown;
+    bool m_dotiming;
+    bool m_dotraces;
+    bool m_reqtraces;
+    string m_suitename;
+    uint m_repeat = 1;
+    bool m_firstingroup=true;
+
+    TestCase m_curcase;
+    TestCase[] m_testcases;
+    TestCase[] m_tcfailed;
+    TestGroup m_curgroup;
+    TestGroup[] m_testgroups;
+    real m_elapsedtime=0;
+
+    uint m_tccounter, m_tcfcounter;
+}
-
-//------------------------------------------------------------------------------
@@ -164 +599 @@
-
-//------------------------------------------------------------------------------
+
+bool isNan(real x) {
+    if (x is real.nan) return true;
+    return false;
+}
+
+bool compareFloats(T)(T first, T second) {
+    trace(first, "  ??  ", second);
+    if (isNan(first) || isNaN(second)) {
+        return isNaN(first) && isNaN(second);
+    }
+    return first == second;
+}
+
+bool compareRefs(T)(T first, T second) {
+    trace(first, "  ??  ", second);
+    if (first is null || second is null) {
+        return first is second;
+    }
+    return cast(bool)(first == second);
+}
+
+//------------------------------------------------------------------------------
-//TODO: don't work for all types e.g. pointers
-bool compareArrays(T)(T first, T second) {
-    static assert(isArray!(T), "Template function can compare only arrays");
+    alias arrayElementType!(T) ElemType;
-
-    if (first.length != second.length) return false;
-
+    bool res = true;
-    foreach(i, v; first) {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -210 +667 @@
-//TODO: add versions without file and line
-//TODO: unit testy tylko w wersji debug
-//------------------------------------------------------------------------------
-
-void tracefl(T...)(string file, long line, T params) {
-    debug traces[tc_counter] ~= Trace(format(params), line, file);
-}
-
-//------------------------------------------------------------------------------
-
-void trace(T...)(T params) {
-    debug traces[tc_counter] ~= Trace(format(params));
-}
-
-//------------------------------------------------------------------------------
-
-private void printTraces(uint no) {
-    string lastfile = "";
-    foreach(t; traces[no]) {
-        if (t.file != lastfile) {
-            writefln(table_simple, " ");
-            if (t.file != "") writefln(table_fail_row2, getBaseName(t.file) ~ ":");
-                else writefln(table_simple, " ");
-            lastfile = t.file;
-        }
-
-        if (t.line !=0) writefln(table_fail_row2, format("%4d:  %s", t.line, t.trace));
-            else writefln(table_fail_row2, format("%s", t.trace));
-    }
-}
-
-//TODO: funkcja porównujÄ
-ca dwie tablice wartości/referencji
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/doost/util/serializer/Registry.d

@@ -175 +175 @@
-
-/*******************************************************************************
-
+n
- ******************************************************************************/
-interface Registration {

trunk/doost/util/serializer/Serializer.d

@@ -78 +78 @@
-//------------------------------------------------------------------------------
-
-
-
+
-//ENH: lack of static access to some member of templates without instantiation needed
-//BUG: inner class Archive is invisible in default parameter of template
-
+CONCRETE
-//ENH: when parameter of function is preceeding by alias, stringof on this parameter
-//should give original name of symbol
-
-private:
+    const info = "Type '" ~ STORAGE.stringof ~ "' does not meet Storage requirements: ";
+    static assert(is(typeof(STORAGE.init) == STORAGE), info ~ "lack of init() method.");
+    static assert(is(typeof(STORAGE.dup) == STORAGE), info ~ "lack of dup() method.");
+
-    enum Mode {LOAD, DUMP}
-
-
+
-
-    static synchronized Archive m_archive;
@@ -105 +107 @@
-        init(m_archive);
-    }
-    //TODO: dorobić JSONArchive
-
-    /***************************************************************************
@@ -201 +202 @@
-
-        //Eventual additional operations ... at begining of traverse...
-
+
+
-        static if (is(typeof(begin!(VALUE)(value, archive)) == bool)) {
-            begin!(VALUE)(value, archive);
@@ -273 +275 @@
-        } else
-        //Other built-in types
+        //TODO: rozbić isAtomic na Integral i Floating i Char
-        static if (isAtomic!(VALUE)) {
-            if (archive.mode == Mode.LOAD) return loadAtomic(value, archive);
@@ -284 +287 @@
-    }
-
+    //TODO: move checking for version and functions inside user UDT into
+    //serializer from Archive. How?
+
+    /***************************************************************************
+     **************************************************************************/
+    bool attendFields(VALUE)(ref VALUE value, Archive archive) {
+        //Load function exists
+        static if ( is(typeof(&value.loadUdt!(Archive)) == void delegate(Archive))) {
+            if (archive.mode == Mode.LOAD) {value.loadUdt(archive); return true;}
+        }
+        //Dump function exists
+        static if ( is(typeof(&value.dumpUdt!(Archive)) == void delegate(Archive))) {
+            if (archive.mode == Mode.DUMP) {value.dumpUdt(archive); return true;}
+        }
+        //TODO: moÅŒna zmniejszyć wielkość funkcji przez sprawdzenie, czy obie powyÅŒsze
+        //funkcje udało się zainstancjować. jeÅŒeli tak to poniÅŒsze nie musi być wstawiane
+
+        //Exists describe function
+        static if ( is(typeof(&value.describeUdt!(Archive)) == void delegate(Archive))) {
+            value.describeUdt(archive);
+        } else
+        //All fields are visible
+        static if (areUdtFieldsVisible!(VALUE)) {
+            foreach(i, v; value.tupleof) {
+                if (archive.mode == Mode.LOAD) {
+                    normalizedType!(typeof(v)) elem;
+                    loadOneField(elem, value.tupleof[i].stringof, archive);
+                    checkType!(typeof(v))(elem);
+
+                    static if (isStaticArray!(typeof(v))) {
+                        foreach(n, saval; value.tupleof[i]) value.tupleof[i][n] = elem[n];
+                    } else {
+                        value.tupleof[i]= elem;
+                    }
+
+                } else {
+                    normalizedType!(typeof(v)) elem = v;
+                    dumpOneField(elem, value.tupleof[i].stringof, archive);
+                }
+            }
+        } else {
+            //FIXME:
+            static assert(false, "UDT '" ~ VALUE.stringof ~ "' is not serializable.");
+        }
+
+        return true;
+    }
+
+
+    /***************************************************************************
+        Returns: true if class was imported by this function
+     **************************************************************************/
+    bool attendVersion(VALUE)(ref VALUE value, Archive archive, uint stored_ver) {
+        if (stored_ver > 0) {
+            uint defined_ver = 0;
+            //more important is version in registry; it allows to override
+            //mistakenly defined versions in classes...
+            static if (is(typeof((cast(VALUE)value).versionUdt) == uint)) {
+                defined_ver = (cast(VALUE)value).versionUdt;
+            }
+            if (auto peek = archive.registry.peek!(TypeDescription, VALUE)) {
+                uint ver = peek.ver;
+                if (ver>0) defined_ver = ver;
+            }
+            if (stored_ver != defined_ver && defined_ver>0) {
+                static if ( is(typeof(&value.importUdt!(Archive)) == void delegate(ref VALUE, Archive, uint))) {
+                    //FIXME: przy imporcie pola nie będÄ
+ zparsowane??? (JSON)
+                    value.importUdt(value, archive, stored_ver);
+                    return true;
+                } else {
+                    throw new SerializerException("Udt version in storage is different than in program");
+                }
+            }
+        }
+        return false;
+    }
+
+
-//------------------------------------------------------------------------------
-
@@ -292 +374 @@
-        //BUG: private attribute is not applied to template functions
-
+        //Bug - jak sprawdzić czy poniÅŒsze jest zdefiniowane?
+        mixin ArchiveExt;
+
-        this() {
-            registry = new Registry;
@@ -299 +384 @@
-        Registry registry;
-
-