root/trunk/doost/util/serializer/archive/JsonArchive.d

/*******************************************************************************

    License:    Boost Software License, v. 1.0
                Academic Free License, v. 3.0
                BSD License

    Authors:    Marcin Kuszczak, www.zapytajmnie.com (author's christian site)

    Version:    0.9.1
    Date:       30-Apr-2008

    History:    0.9.1 (30-Apr-2008) -   initial public version

 ******************************************************************************/

module doost.util.serializer.archive.JsonArchive;

//------------------------------------------------------------------------------
// BUG: DSSS can't pick this out from the template below
//      http://www.dsource.org/projects/dsss/ticket/193
import doost.text.Escaper;

/*******************************************************************************
    This is JSON format archive for serializer.

    Internal policy for returning bool from loaders/dumpers:
    1. true - value was properly loaded/dumped
    2. exception - loading of value was not succesfull (token not found or found
       but is wrongly formatted)

 ******************************************************************************/

template JsonArchive(ARCHIVE) {
private:
    //Static functions and definitions

    import std.regexp;
    import std.typetuple;
    import std.conv;
    import std.range;
    import std.utf;
    import std.string : format;

    import doost.api.Common;
    import doost.util.serializer.Registry;
    import doost.text.Escaper;
    import doost.text.Scanner;
    import doost.text.ElementSet;
    import doost.text.SequenceSet;
    import doost.text.Matcher;

    import doost.util.serializer.Exception;

    alias TypeTuple!(string, wstring, dstring) AvailableStorageTypes;

    //------------------------------------------------------------------------------

    private static struct Skip {
        static STORAGETYPE space = " ";
        static STORAGETYPE newline = "\n";
        static STORAGETYPE indent = "    ";
        static auto skip = ElementSet!(dchar).whitespace;
    }

    private static struct Bool {
        static STORAGETYPE positive = "true";
        static STORAGETYPE negative = "false";
    }

    private static struct String {
        static auto delimiter = SequenceSet!(STORAGETYPE).strdelim;
        static auto escdesc = &scanEscapeSequence!(STORAGE);
        static auto allchars = ElementSet!(dchar).extended_alphanum;
        static auto midchars = ElementSet!(dchar).digit;
        static ELEMENTTYPE sdelimiter = '"';
        static ELEMENTTYPE cdelimiter = '\'';
    }

    private static struct Region {
        static auto begin = SequenceSet!(STORAGETYPE).openingbrackets;
        static auto end = SequenceSet!(STORAGETYPE).closingbrackets;
    }

    private static struct Reference {
        static STORAGETYPE defnull = "null";
        static ELEMENTTYPE defref = '$';
        static ELEMENTTYPE pointer = '*';
    }

    private static struct Array {
        static ELEMENTTYPE begin = '[';
        static ELEMENTTYPE separator = ',';
        static ELEMENTTYPE end = ']';
    }

    private static struct Udt {
        static STORAGETYPE ver = "versionUdt";
        static ELEMENTTYPE begin = '{';
        static ELEMENTTYPE kvseparator = ':';
        static ELEMENTTYPE separator = ',';
        static ELEMENTTYPE end = '}';
    }

    //--------------------------------------------------------------------------

        bool mismatch = false;
        STORAGETYPE rest = STORAGETYPE.init;
        uint indent = 0;
        bool line_begin = true;

        //fields of specific class with values: content[name of fields]
        STORAGETYPE[STORAGETYPE] memberStructFields;

        Archive dup_infoext() {
            Archive result = new Archive;
            result.mismatch = false;
            result.rest = STORAGETYPE.init;
            return result;
        }

    //--------------------------------------------------------------------------

    /*******************************************************************************
     ******************************************************************************/
    static class TypeDescription(T) : Registration {
        mixin TypeDescriptionBase!(T) DEFAULT;

        public typeof(this) dup_info() {
            typeof(this) result = DEFAULT.dup_info;
            return result;
        }
    }

    /***************************************************************************
     **************************************************************************/
    bool init() {
        return true;
        //BUG: po dodaniu przecinka w ostatniej linijce dla tablic asocjacyjnych wyskakuje błÄ
d
    }

    /***************************************************************************
        This function is started every time when serialization work is started.
        It is good place to put code which will load/dump headers.
     **************************************************************************/
    bool start() {
        return true;
    }

    /***************************************************************************
        If this function exists in Archive it is called on every traverse, at the
        beginning of traverse.
     **************************************************************************/
    bool begin(VALUE)(ref VALUE value) {
        return true;
    }

    /***************************************************************************
        This function is started every time when serialization work is finished.
        It is good place to put code which will load/dump footers.
     **************************************************************************/
    bool finish(VALUE)(VALUE value) {
        return true;
    }

    /***************************************************************************
        Return the indentation string for the current indentation level.
        Does not use or modify the line_begin flag.
     **************************************************************************/
    STORAGETYPE indentString() {
        STORAGETYPE indent_str = STORAGETYPE.init;
        for(int i=0; i<indent; i++) {
            indent_str ~= Skip.indent;
        }
        return indent_str;
    }

    /***************************************************************************
        Write the current indentation string to the storage.
        Postcondition: line_begin flag set to false.
     **************************************************************************/
    bool dumpIndent() {
        line_begin = false;
        storage.put(indentString());
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadString(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);

        auto m = scanString!(STORAGE)(storage, String.delimiter, String.escdesc, String.allchars, String.midchars);
        if (m.status != Matcher.matched)
            throw new ParsingException("Expected string or char in input, but it wasn't found.");

        STORAGETYPE val;
        val = munch(storage, m);

        auto delim = munch(val, String.delimiter);
        auto len = delim.length;

        if (len>0) {
            val = val[0..$-len];
            val = unescape(val);
        }

        value = to!(VALUE)(val);

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpString(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put( String.sdelimiter ~
                            to!(STORAGETYPE)(escape(value)) ~
                            String.sdelimiter);
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    Matcher scanBool(ref STORAGE input) {
        Matcher mp;

        mp = scan(input, Bool.positive); if (mp.status == Matcher.matched) return mp;
        mp = scan(input, Bool.negative); if (mp.status == Matcher.matched) return mp;

        return Matcher(0, Matcher.mismatch);
    }

    /***************************************************************************
        Loads bool from Storage. Not intended to be used by library user.

        Returns: true on success
        Throws: ParsingException
     **************************************************************************/
    bool loadBool(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);
        STORAGETYPE literal;

        auto mp = scanBool(storage);
        if (mp.status == Matcher.matched) {
            literal = munch(storage, mp);
        } else throw new ParsingException("Unknown bool literal.");

        if (literal == "true") value = true;
            else value = false;

        return true;
    }

    /***************************************************************************
        Dumps bool to Storage. Not intended to be used by library user.

        Returns: true on success
     **************************************************************************/
    bool dumpBool(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put((value == true) ? Bool.positive
                            : Bool.negative);
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadNumber(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);
        auto m = scanNumber(storage);
        if (m.status != Matcher.matched) throw new ParsingException("Expected number in source, but it wasn't found.");

        value = to!(VALUE)(munch(storage, m));
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpNumber(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put(to!(STORAGETYPE)(value));
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadChar(VALUE)(ref VALUE value) {
        STORAGETYPE val;
        loadString(val);

        size_t idx = 0;
        dchar c = decode(val, idx);

        idx++;
        if (idx < val.length) throw new ParsingException(format(ErrorStrings.WRONG_CHAR_LITERAL, val));

        static if (is(Unqual!VALUE == char)) {
            if (c > 127) throw new SerializerException(format(ErrorStrings.CHAR_CONV_ERROR, cast(uint)c, VALUE.stringof));
            value = cast(VALUE)c;
        } else
        static if (is(Unqual!VALUE == wchar)) {
            if (c > 32767) throw new SerializerException(format(ErrorStrings.CHAR_CONV_ERROR, cast(uint)c, VALUE.stringof));
            value = cast(VALUE)c;
        } else
        static if (is(Unqual!VALUE == dchar)) {
            value = c;
        } else {
            static assert(false, "Wrong type passed to loadChar method: " ~ VALUE.stringof);
        }

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpChar(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put(String.cdelimiter ~ to!(STORAGETYPE)(value) ~ String.cdelimiter);
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadElement(VALUE, SEP)(ref VALUE value, SEP esep) {
        if (mismatch) throw new ParsingException("Missing elements separator.");
        bool matched = traverse(value);
        if (!matched) return false;

        skip(storage, Skip.skip, uint.max);
        mismatch = !skip(storage, esep);
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpElement(VALUE, SEP)(ref VALUE value, SEP sep) {
        if (line_begin) dumpIndent();
        storage.put(rest);
        bool res = traverse(value);
        rest = sep ~ Skip.space;
        return res;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadArray(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);

        if (!skip(storage, Array.begin))
            throw new ParsingException("Missing array literal begining delimiter.");

        ElementType!(VALUE) elem;
        VALUE result;
        mismatch = false;
        do {
            skip(storage, Skip.skip, uint.max);
            if (skip(storage, Array.end)) break;
            loadElement(elem, Array.separator);
            result ~= elem;
        } while(true);

        value = result;
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpArray(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put(Array.begin);

        rest = STORAGETYPE.init;
        foreach(v; value)
            dumpElement(v, Array.separator);

        storage~=Array.end;
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadAssociativeElement(KEY, VALUE, KVSEP, SEP)(ref KEY key, ref VALUE value, KVSEP kvsep, SEP esep) {
        if (mismatch) throw new ParsingException("Missing associative elements separator.");
        bool matched = traverse(key);
        if(!matched) return false;

        skip(storage, Skip.skip, uint.max);
        if (!skip(storage, kvsep))
            throw new ParsingException("Missing associative array literal key-value separator.");

        traverse(value);

        skip(storage, Skip.skip, uint.max);
        if (!skip(storage, esep)) mismatch = true;

        return matched;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpAssociativeElement(KEY, VALUE, KVSEP, SEP)(ref KEY key, ref VALUE value, KVSEP kvsep, SEP esep) {
        storage.put(rest);
        traverse(key);
        if (line_begin) dumpIndent();
        storage.put(Skip.space ~ kvsep ~ Skip.space);
        traverse(value);
        rest = esep ~ Skip.newline ~ indentString();

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadAssociativeArray(VALUE)(ref VALUE value) {
        alias typeof(VALUE.init.values[0]) ValueType;
        alias typeof(VALUE.init.keys[0]) KeyType;

        skip(storage, Skip.skip, uint.max);
        if (!skip(storage, Udt.begin))
            throw new ParsingException("Missing associative array literal begining delimiter.");

        KeyType key;
        ValueType val;
        VALUE result;

        mismatch = false;
        do {
            skip(storage, Skip.skip, uint.max);
            if (skip(storage, Udt.end)) break;
            loadAssociativeElement(key, val, Udt.kvseparator, Udt.separator);
            result[key] = val;
        } while(true);

        value = result;
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpAssociativeArray(VALUE)(ref VALUE value) {
        alias typeof(VALUE.init.values[0]) ValueType;
        alias typeof(VALUE.init.keys[0]) KeyType;

        KeyType key;
        ValueType val;

        if (line_begin) dumpIndent();
        storage.put(Udt.begin ~ Skip.newline);
        line_begin = true;
        indent++;

        rest = STORAGETYPE.init;
        foreach(k, v; value) {
            dumpAssociativeElement(k, v, Udt.kvseparator, Udt.separator);
        }
        indent--;
        storage.put(Skip.newline);
        line_begin = true;
        if (line_begin) dumpIndent();
        storage.put(Udt.end);

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    Matcher scanRef(ref STORAGE input) {
        Matcher m;
        m = scan(input, Reference.defref);
        if (m.status != Matcher.matched) return m;
        m = scan(input, ElementSet!(dchar).digit, 0u, uint.max);
        return m;
    }


    /***************************************************************************
     **************************************************************************/
    Matcher scanNull(ref STORAGE input) {
        return scan(input, Reference.defnull);
    }

    /***************************************************************************
     **************************************************************************/
    bool loadRef(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);
        if (skip(storage, Reference.defnull)) {
            value = null;
            return true;
        }

        if (tracking == Tracking.ON) {
            if (skip(storage, Reference.defref)) {
                uint symbol;
                if (!traverse(symbol)) throw new ParsingException("Lack of symbol!");
                value = registry.get!(TypeDescription, VALUE).address(symbol);
                return true;
            }
        }

        static if (!is(VALUE == class)) {
            skip(storage, Skip.skip, uint.max);
            if (!skip(storage, Reference.pointer))
                throw new ParsingException("Lack of pointer symbol.");
        }
        return false;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpRef(VALUE)(ref VALUE value) {
        if (value is null) {
            if (line_begin) dumpIndent();
            storage.put(Reference.defnull);
            return true;
        }

        if (tracking == Tracking.ON) {
            uint symbol = registry.get!(TypeDescription, VALUE).symbol(value);
            if (symbol > 0) {
                if (line_begin) dumpIndent();
                storage.put(Reference.defref ~ to!(STORAGETYPE)(symbol));
                return true;
            }
        }

        static if (!is(VALUE == class)) {
            if (line_begin) dumpIndent();
            storage.put(Reference.pointer);
        }

        return false;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadVersion(ref uint stored_ver) {
        stored_ver = 0;

        if (Udt.ver in memberStructFields) {
            try {
                stored_ver = to!(uint)(memberStructFields[Udt.ver]);
            } catch(Exception e) {
                throw new ParsingException("Wrong version format: \n" ~ e.toString);
            }
            return true;
        }
        return false;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpVersion(ref uint defined_ver) {
        if (defined_ver>0) memberStructFields[Udt.ver] = to!(STORAGETYPE)(defined_ver);
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    string normalizeName(string name) {
        int pos = std.string.lastIndexOf(name, '.');
        if (pos > 0) name = name[pos+1..$];
        return name;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadOneField(VALUE)(ref VALUE value, string n) {
        n = normalizeName(n);
        STORAGETYPE name = to!STORAGETYPE(n);

        if (!(name in memberStructFields)) {
            throw new ParsingException("Field is not defined in input: " ~ n);
        }

        *storage.frame() = memberStructFields[name] ~ *storage.frame();

        if (!traverse(value))
            throw new ParsingException("Parsing error");

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpOneField(VALUE)(ref VALUE value, string name) {
        name = normalizeName(name);

        if (!dumpAssociativeElement(name, value, Udt.kvseparator, Udt.separator))
            throw new SerializerException("Can not dump'" ~ VALUE.stringof ~ "'.");
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool loadFields(VALUE)(ref VALUE value) {
        //FIXME: czy na pewno ten mismatch jest tu potrzebny?
        mismatch = false;
        processMemberStructFields(value);

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpFields(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put(String.sdelimiter
                        ~   to!STORAGETYPE(VALUE.stringof)
                        ~   String.sdelimiter
                        ~   Skip.space
                        ~   Udt.kvseparator
                        ~   Skip.space
                        ~   Udt.begin
                        ~   Skip.newline);
        line_begin = true;
        indent++;

        if (Udt.ver in memberStructFields) {
            if (line_begin) dumpIndent();
            storage.put(String.sdelimiter
                            ~   Udt.ver
                            ~   String.sdelimiter
                            ~   Skip.space
                            ~   Udt.kvseparator
                            ~   Skip.space
                            ~   memberStructFields[Udt.ver]
                            ~   Udt.separator
                            ~   Skip.newline);
            line_begin = true;
        }

        rest = STORAGETYPE.init;
        processMemberStructFields(value);

        indent--;
        storage.put(Skip.newline);
        line_begin = true;
        if (line_begin) dumpIndent();
        storage.put(Udt.end ~  Skip.newline);
        line_begin = true;
        return true;
    }

    //BUG: remove differences between char and string (implicit conversion) ?? string s = char; ok

    /***************************************************************************
     **************************************************************************/
    bool tokenizeMemberStructFields(string n, STORAGETYPE[STORAGETYPE] includedclasses) {
        STORAGETYPE name = to!STORAGETYPE(n);
        if (!(name in includedclasses))
            throw new ParsingException("class is not defined in source");

        skip(storage, Skip.skip, uint.max);

        memberStructFields = null;

        STORAGETYPE key;
        STORAGETYPE val;

        *storage.frame() = includedclasses[name] ~ *storage.frame();

        if (!skip(storage, Udt.begin))
            throw new ParsingException("No Udt begining delimiter");

        bool last;

        do {
            skip(storage, Skip.skip, uint.max);
            if (skip(storage, Udt.end)) break;
            if (last) throw new ParsingException("Missing Udt separator");

            key = STORAGETYPE.init;
            loadString(key);

            skip(storage, Skip.skip, uint.max);
            if (!skip(storage, Udt.kvseparator))
                throw new ParsingException("No kvseparator");
            skip(storage, Skip.skip, uint.max);

            auto mp = scanValue(storage);
            if (mp.status == Matcher.matched) {
                val = munch(storage, mp);
            } else throw new ParsingException("No value for Udt field");

            if (!skip(storage, Udt.separator)) {
                last = true;
            }

            if (key in memberStructFields)
                throw new ParsingException("Duplicated field entries in source.");

            memberStructFields[key] = val;
        } while(true);

        return true;

    }

    //TODO: do importu. moÅŒna zarejestrować nowÄ
 nazwę do starej klasy memberStruct
    //tak, aby w imporcie było to automatycznie mapowane
    /***************************************************************************
     **************************************************************************/
    bool loadUdt(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);

        if (!skip(storage, Udt.begin))
            throw new ParsingException(format(ErrorStrings.MISSING_BEGINNING_DELIMITER, Udt.begin));

        STORAGETYPE[STORAGETYPE] includedclasses; // all classes which are part of higher level class
        STORAGETYPE key;
        STORAGETYPE val;
        bool last = false;

        Matcher m;

        do {
            key = STORAGETYPE.init;
            if (skip(storage, Udt.end)) break;

            loadString(key);

            if (last) throw new ParsingException("No Udt separator");

            if (key in includedclasses)
                throw new ParsingException("Duplicated class information!");

            skip(storage, Skip.skip, uint.max);
            if (!skip(storage, Udt.kvseparator))
                throw new ParsingException("Missing key - value separator");

            skip(storage, Skip.skip, uint.max);
            m = scanRegion!(STORAGE)(storage, Region.begin, Region.end, String.delimiter, String.escdesc, String.allchars, String.midchars);

            //BUG: nie moÅŒna porównać char i string
            if (m.status == Matcher.matched && storage.peek() == Udt.begin) val = munch(storage, m);
                else throw new ParsingException("Unknown token");

            skip(storage, Skip.skip, uint.max);

            if (!skip(storage, Udt.separator)) {
                last = true;
            }

            includedclasses[key] = val;
        } while(true);

        tokenizeMemberStructFields(VALUE.stringof, includedclasses);
        processMemberStruct(value);

        static if( is( VALUE == class )) {
            //BUG: a way to create class without using constructor
            //BUG: a way to access all fields from class neverthless of protection attributes

            foreach(i, BASE; BaseTypeTuple!(VALUE)) {
                static if (!is(BASE == interface) && BASE.tupleof.length != 0)
                {
                    BASE res = cast(BASE)value;
                    tokenizeMemberStructFields(BASE.stringof, includedclasses);
                    processMemberStruct(res);
                }
            }
        }

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpUdt(VALUE)(ref VALUE value) {
        if (line_begin) dumpIndent();
        storage.put( Udt.begin ~ Skip.newline);
        indent++;
        line_begin = true;

        processMemberStruct(value);

        static if( is( VALUE == class )) {
            foreach(i, BASE; BaseTypeTuple!(VALUE)) {
                static if (is (BASE == interface) || BASE.tupleof.length == 0) {}
                else {
                    if (line_begin) dumpIndent();
                    storage.put(Udt.separator ~ Skip.newline);
                    line_begin = true;
                    BASE val = cast(BASE)value;
                    processMemberStruct(val);
                }
            }
        }

        indent--;
        if (line_begin) dumpIndent();
        storage.put(Udt.end);

        return true;
    }

    /***************************************************************************
     **************************************************************************/
    Matcher scanValue(ref STORAGE input) {
        Matcher m;
        //arrays + udt
        m = scanRegion!(STORAGE)(input, Region.begin, Region.end, String.delimiter, String.escdesc, String.allchars, String.midchars);
        if (m.status == Matcher.matched) return m;

        m = scanNull(input);
        if (m.status == Matcher.matched) return m;

        m = scanRef(input);
        if (m.status == Matcher.matched) return m;

        m = scanNumber(input);
        if (m.status == Matcher.matched) return m;

        //Char will be threated as String
        m = scanString!(STORAGE)(input, String.delimiter, String.escdesc, String.allchars, String.midchars);
        if (m.status == Matcher.matched) return m;

        return Matcher(0, Matcher.mismatch);
    }
}

/*******************************************************************************
 ******************************************************************************/
template JsonArchiveExt(ARCHIVE) {
private:
    import std.date;
    import std.string;
    import doost.api.Common;
    import doost.util.serializer.archive.JsonArchive;
    import doost.text.Scanner;

    string[] days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];

    mixin JsonArchive!(ARCHIVE);

    /***************************************************************************
     **************************************************************************/
    //TODO: funkcje load.. powinny zwracać matchera
    bool loadDate(VALUE)(ref VALUE value) {
        skip(storage, Skip.skip, uint.max);

        auto m = scanDate(storage);
        if (!cast(bool)m) throw new SerializerException("Can not load date!");

        auto str = munch(storage, m);
        value.parse(str);
        return true;
    }

    /***************************************************************************
     **************************************************************************/
    bool dumpDate(VALUE)(ref VALUE value) {
        if (value.weekday>0 && value.weekday<8) storage.put(days[value.weekday-1]~", ");

        storage.put(format("%4s-%02s-%02s %02s:%02s:%02s",
            value.year, value.month, value.day, value.hour, value.minute,
            value.second));

        if (value.tzcorrection > int.min && value.tzcorrection!=0) {
            storage.put(" ");
            if (value.tzcorrection>0) storage.put("+");
            storage.put(format(value.tzcorrection));
        }
        return true;
    }

    //BUG: not possible to do it
    //alias TextArchive!(ARCHIVE).Pattern Pattern;
    //mixin(generator("Pattern(T : Date)", ["pattern", r"\d\d\d\d-[\d]?\d-[\d]?\d[ \d\d:\d\d:\d\d[.\d\d\d]?]?"]));

    /***************************************************************************
     **************************************************************************/
    //BUG: can not mixin this as traverse because symbol is already defined
    bool extend(VALUE: Date)(ref VALUE value) {
        if (mode == Mode.LOAD) return loadDate!(VALUE)(value);
            else return dumpDate!(VALUE)(value);
    }
}