/home/renji/Data/projects/zenlang/sources/zbl/zbl.hpp

Go to the documentation of this file.

#pragma once

// All Qt headers must be included in the pch.hpp file at this point
#ifndef PCH_INCLUDED
#error PCH file not included
#endif

#define unused Q_UNUSED

#define assert(c) {if(!(c)) abort();}

#define registerMetatype(T) Q_DECLARE_METATYPE(T)

namespace zd {

    struct counted {
        explicit inline counted(const char* n) : name(n), cnt(0) {}

        inline ~counted() {
            qDebug() << name << cnt;
        }

        const char* name;

        int cnt;
    };


    struct counter {
        explicit inline counter(counted& fn) : _fn(fn) {
            tmr.start();
        }

        inline ~counter() {
            _fn.cnt += tmr.elapsed();
        }

        QTime tmr;

        counted& _fn;
    };
}


template <typename T>
inline T* ptr(T& t) {
    assert(0 != &t);
    return &t;
}


template <typename T>
inline T& ref(T* t) {
    assert(t);
    return *t;
}


template <typename T>
inline const T* ptr(const T& t) {
    assert(0 != &t);
    return &t;
}


template <typename T>
inline const T& ref(const T* t) {
    assert(t);
    return *t;
}

typedef char byte;

typedef long long int64;

namespace z {

    class date {
    public:
        explicit inline date(const int& yy, const int& mm, const int& dd) : _val(yy, mm, dd){}

    public:
        inline QDate& get() const {return const_cast<QDate&>(_val);}

    private:
        QDate _val;
    };


    class time {
    public:
        explicit inline time(const int& hh, const int& mm, const int& ss) : _val(hh, mm, ss){}

    public:
        inline QTime& get() const {return const_cast<QTime&>(_val);}

    private:
        QTime _val;
    };


    class datetime {
    public:
        explicit inline datetime(const date& dd, const time& tt) : _val(dd.get(), tt.get()){}

    public:
        inline QDateTime& get() const {return const_cast<QDateTime&>(_val);}

    private:
        QDateTime _val;
    };

    class any;


    class string {
    public:
        explicit inline string(){}

        inline string(const char* val) : _val(val) {}

        explicit inline string(const QString& val) : _val(val) {}

    public:
        inline string& operator =(const char* val)   {_val = val; return ref(this);}

        inline string& operator =(const string& val) {_val = val._val; return ref(this);}

        inline string& operator+=(const int& chr)    {_val.append(QChar(chr)); return ref(this);}

        inline string& operator+=(const string& src) {_val += src._val; return ref(this);}

        inline string& operator+=(const char* src)   {_val += src; return ref(this);}

    public:
        inline bool operator==(const string& src) const {return _val == src._val;}

        inline bool operator==(const char*   src) const {return _val == src;}

        inline bool operator!=(const string& src) const {return _val != src._val;}

        inline bool operator!=(const char*   src) const {return _val != src;}

        inline bool operator< (const string& src) const {return _val < src._val;}

        inline string operator+ (const string& src) const {return string(_val + src._val);}

        inline string operator+ (const char*   src) const {return string(_val + src);}

    public:
        inline int at(const int& idx) const {return _val.at(idx).unicode();}

        inline bool has(const int& ch) const {return _val.contains(QChar(ch));}

        inline int find(const z::string& sub) const {return _val.indexOf(sub.get());}

        inline string mid(const int& start, const int& len = -1) const {return string(_val.mid(start, len));}

        inline long toLong() const {return _val.toLong();}

        inline string leftJustified(const int& w) const {return string(_val.leftJustified(w));}

        inline int length() const {return _val.length();}

        inline void replace(const int& ch, const int& with) {_val.replace(QChar(ch), QChar(with));}

    public:
        inline const char* toUtf8(char buf[], const int& len) const {
            QByteArray arr = _val.toUtf8();
            for(int i = 0; (i < arr.size()) && (i < (len-1)); ++i) {
                buf[i] = arr.at(i);
                buf[i+1] = 0;
            }
            return buf;
        }

    public:
        inline QString& get() const {return const_cast<QString&>(_val);}

    public:
        class creator {
        public:
            inline creator(const string& val) : _val(val.get()) {}

        public:
            inline creator& arg(const z::any& key, const z::any& val);

            inline z::string value() {return string(_val);}

        private:
            QString _val;
        };

    private:
        QString _val;
    };

    inline z::string operator+(const char* src, const z::string& dst) {
        return z::string(src + dst.get());
    }

    inline QDebug operator<<(QDebug db, const z::string& ss) {
        db << ss.get();
        return db;
    }

    inline uint qHash(const z::string& key) {return qHash(key.get());}

    inline uint qHash(const double& key) {return ::qHash((qlonglong)(key*100));}


    template<typename T>
    class sharedptr {
    public:
        explicit inline sharedptr(T* t) : _ptr(t) {}

        inline T& operator*() const {return *_ptr;}

    private:
        QSharedPointer<T> _ptr;
    };


    template<typename T>
    class autoptr {
    public:
        explicit inline autoptr() : _ptr(0) {}

        explicit inline autoptr(T* t) : _ptr(t) {}

        inline ~autoptr() {delete _ptr;}

    public:
        inline void operator=(T* t)  {_ptr = t;}

        inline T& operator*() const  {return ref(_ptr);}

        inline T* operator->() const {return _ptr;}

        inline T* data() const {return _ptr;}

        inline bool isNull() const {return (0 == _ptr);}

        inline T* take() {T* t = _ptr; _ptr = 0; return t;}

        inline T* reset(T* n) {T* t = _ptr; _ptr = n; return t;}

    private:
        T* _ptr;
    };


    template<typename T>
    class scopedptr {
    public:
        explicit inline scopedptr() : _ptr() {}

        explicit inline scopedptr(T* t) : _ptr(t) {}

    public:
        inline T& operator*() const {return *_ptr;}

        inline T* operator->() const {return _ptr.data();}

        inline T* data() const {return _ptr.data();}

        inline bool isNull() const {return _ptr.isNull();}

        inline T* take() {return _ptr.take();}

        inline void reset(T* t) {return _ptr.reset(t);}

    private:
        QScopedPointer<T> _ptr;
    };


    template<typename V>
    class owner {
    public:
        inline V& insert() {
            V* v = new V();
            _list.insert(v);
            return ref(v);
        }

        inline void remove(V& v) {
            typename List::iterator it = _list.find(ptr(v));
            assert(it != _list.end());
            V* o = *it;
            assert(o == ptr(v));
            _list.erase(it);
            delete o;
        }

    private:
        typedef QSet<V*> List;

        List _list;
    };


    template<typename V>
    class holder {
    public:
        inline V& insert(V* v) {
            _list.insert(v);
            return ref(v);
        }

        inline void remove(V& v) {
            typename List::iterator it = _list.find(ptr(v));
            assert(it != _list.end());
            V* o = *it;
            assert(o == ptr(v));
            _list.erase(it);
            delete o;
        }

    private:
        typedef QSet<V*> List;

        List _list;
    };


    template<typename iterT, typename V>
    class iteratorbase {
    public:
        explicit inline iteratorbase(const iterT& iter) : _iter(iter) {}

    public:
        inline bool begin() const {return !_iter.hasPrevious();}

        inline bool end() const {return !_iter.hasNext();}

        inline bool operator!=(const iteratorbase& src) const {return _iter != src._iter;}

        inline bool operator==(const iteratorbase& src) const {return _iter == src._iter;}

        inline void toBack() {return _iter.toBack();}

    protected:
        iterT _iter;
    };


    template<typename iterT, typename V>
    class iteratorbaseL : public iteratorbase<iterT, V> {
    private:
        typedef iteratorbase<iterT, V> baseT;

    public:
        explicit inline iteratorbaseL(const iterT& iter) : baseT(iter) {}

    public:
        inline const V& operator++() {return baseT::_iter.next();}

        inline const V& operator--() {return baseT::_iter.previous();}

        inline const V& operator*() const {return baseT::_iter.peekNext();}
    };


    template<typename iterT, typename K, typename V>
    class iteratorbaseD : public iteratorbase<iterT, V> {
    private:
        typedef iteratorbase<iterT, V> baseT;

    public:
        explicit inline iteratorbaseD(const iterT& iter) : baseT(iter) {}

    public:
        inline const V& operator++() {return baseT::_iter.next().value();}

        inline const V& operator--() {return baseT::_iter.previous().value();}

        inline const V& operator*() const {return baseT::_iter.peekNext().value();}

        inline const K& key() const {return baseT::_iter.peekNext().key();}

    public:
        inline bool find(const K& key) const {return !baseT::_iter.findNext(key);}
    };


    template<typename listT>
    class containerbase {
    protected:
        explicit inline containerbase() {}

        explicit inline containerbase(const containerbase& src) : _list(src._list) {}

    public:
        inline int size() const {return _list.size();}

    protected:
        listT _list;
    };


    template<typename derT, typename listT, typename iterT, typename V>
    class listbase : public containerbase<listT> {
    private:
        typedef containerbase<listT> baseT;

    public:
        class iterator : public iteratorbaseL<iterT, V> {
        public:
            inline iterator(const derT& list) : iteratorbaseL<iterT, V>(list._list) {}
        };

    public:
        class creator {
        public:
            inline creator() {}

        public:
            inline creator& add(const V& val) {_list.append(val);return ref(this);}

            inline derT& value() {return _list;}

        private:
            derT _list;
        };

    public:
        inline V& operator[](const int& key) {return baseT::_list[key];}

    public:
        inline bool empty() const {return baseT::_list.isEmpty();}

        inline void clear() {baseT::_list.clear();}

        inline void append(const V& v) {baseT::_list.append(v);}

        inline void appendList(const derT& v) {baseT::_list.append(v._list);}

        inline const V& at(const int& idx) const {return baseT::_list.at(idx);}

        inline int indexOf(const V& v) const {return baseT::_list.indexOf(v);}

        inline V& front() {return baseT::_list.front();}

        inline const V& front() const {return baseT::_list.front();}

        inline V& last() {return baseT::_list.last();}

        inline const V& last() const {return baseT::_list.last();}

        inline derT& operator<<(const V& val) {append(val); return static_cast<derT&>(ref(this));}
    };


    template<typename V>
    class list : public listbase<list<V>, QList<V>, QListIterator<V>, V> {
    private:
        typedef listbase<list<V>, QList<V>, QListIterator<V>, V> baseT;
    };


    template<typename V>
    class set : public listbase<set<V>, QSet<V>, QSetIterator<V>, V> {
    private:
        typedef listbase<set<V>, QSet<V>, QSetIterator<V>, V> baseT;

    public:
        inline void insert(const V& v) {baseT::_list.insert(v);}

        inline bool has(const V& v) const { return baseT::_list.contains(v);}
    };


    template<typename V>
    class stack : public listbase<stack<V>, QStack<V>, QVectorIterator<V>, V> {
    private:
        typedef listbase<stack<V>, QStack<V>, QVectorIterator<V>, V> baseT;

    public:
        inline V& top() {return baseT::_list.top();}

        inline const V& top() const {return baseT::_list.top();}

        inline void push(const V& v) {baseT::_list.push(v);}

        inline V pop() { return baseT::_list.pop();}
    };


    template<typename V>
    class queue : public listbase<queue<V>, QQueue<V>, QListIterator<V>, V> {
    public:
        typedef listbase<queue<V>, QQueue<V>, QListIterator<V>, V> baseT;

    public:
        inline V& head() {return baseT::_list.head();}

        inline void enque(const V& v) {baseT::_list.enqueue(v);}

        inline V deque() { return baseT::_list.dequeue();}
    };


    template<typename derT, typename K, typename V>
    class dictbase : public containerbase< QMap<K, V> > {
    private:
        typedef containerbase< QMap<K, V> > baseT;

    public:
        class iterator : public iteratorbaseD<QMapIterator<K, V>, K, V> {
        private:
            typedef iteratorbaseD<QMapIterator<K, V>, K, V> baseT;

        public:
            inline iterator(const derT& list) : baseT(list._list) {}
        };

    public:
        class found {
        public:
            inline found(typename QMap<K, V>::const_iterator iter, typename QMap<K, V>::const_iterator end) : _found(iter != end), _iter(iter) {}

        public:
            inline operator bool() const {return _found;}

            inline const V& operator*() const {return _iter.value();}

        private:
            bool _found;

            typename QMap<K, V>::const_iterator _iter;
        };

    public:
        inline void insert(const K& k, const V& v) {baseT::_list.insert(k, v);}

        inline bool has(const K& k) const { return baseT::_list.contains(k);}

        inline found find(const K& k) const { return found(baseT::_list.find(k), baseT::_list.end());}

    public:
        inline const QMap<K,V>& get() const {return baseT::_list;}

    public:
        inline V& at(const K& key) {
            assert(has(key));
            //V& v = baseT::_list.value(key);
            V& v = baseT::_list[key];
            return v;
        }

    public:
        inline V& operator[](const K& key) {return baseT::_list[key];}

    public:
        class creator {
        public:
            inline creator() {}

        public:
            inline creator& add(const K& key, const V& val) {_list[key] = val;return ref(this);}

            inline derT& value() {return _list;}

        private:
            derT _list;
        };
    };


    template<typename K, typename V>
    class dict : public dictbase< dict<K, V>, K, V > {
    private:
        typedef dictbase< dict<K, V>, K, V > baseT;
    };

    class key;


    class tree : public dictbase< tree, key, any > {
    private:
        typedef dictbase< tree, key, any > baseT;

    public:
        inline tree() {}
    };


    class stringset {
    public:
        explicit inline stringset() {}

    public:
        inline void clear() {_list.clear();}

        inline void insert(const string& v) {_list.insert(v.get());}

        inline bool has(const string& v) const { return _list.contains(v.get());}

    private:
        QSet<QString> _list;
    };


    class stringlist : public z::list<z::string> {
    public:
        inline z::string join(const z::string& sep) const {
            z::string s;
            z::string sep1;
            for(z::list<string>::iterator it(ref(this)); !it.end(); ++it) {
                s += sep1;
                s += *it;
                sep1 = sep;
            }
            return s;
        }

        inline void append(const string& v) {z::list<z::string>::append(v);} 

        inline void append(const stringlist& v) {z::list<z::string>::appendList(v);}
    };


    class buffer {
    public:
        inline QByteArray& get() { return _val;}

        inline const QByteArray& get() const { return _val;}

    public:
        inline int size() const {return _val.size();}

    public:
        class iterator {
        public:
            inline iterator(const buffer& buf) : _buf(buf), _pos(0) {}

        public:
            inline iterator& operator++() {++_pos; return ref(this);}

            inline int operator*() {return _buf.get().at(_pos);}

            inline bool end() {return (_pos >= _buf.size());}

        private:
            const buffer& _buf;

            int _pos;
        };

    public:
        explicit inline buffer(const int& size) : _val(size, 0) {}

        explicit inline buffer(const QByteArray& src) : _val(src) {}

    public:
        inline int operator[](const int& idx) { return _val.at(idx);}

    private:
        QByteArray _val;
    };


    class fileinfo {
    public:
        explicit inline fileinfo(const string& filename) : _val(filename.get()) {}

        explicit inline fileinfo(const string& dir, const string& filename) : _val(dir.get(), filename.get()) {}

    public:
        inline string getAbsoluteFilePath() const { return string(_val.absoluteFilePath()); }

        inline string getBaseName()  const { return string(_val.baseName()); }

        inline string getAbsolutePath() const { return string(_val.absolutePath()); }

        inline string getFilePath() const { return string(_val.filePath()); }

        inline string getFileName() const { return string(_val.fileName()); }

        inline string getSuffix() const { return string(_val.suffix()); }

        inline string getPath() const { return string(_val.path()); }

    public:
        inline bool exists() const { return _val.exists();}

        inline bool isAbsolute() const { return _val.isAbsolute();}

    public:
        static inline string getCanonicalDirPath(const string& file) {return string(QDir(file.get()).canonicalPath());}

        static inline string getCanonicalFilePath(const string& file) {return string(QFileInfo(file.get()).canonicalFilePath());}

    public:
        static inline bool isAbsolute(const string& file) { return fileinfo(file).isAbsolute();}

        static inline string getNativeSeparator(const string& file) { return string(QDir::toNativeSeparators(file.get())); }

        static inline string getAbsolutePath(const string& file) { return fileinfo(file).getAbsolutePath(); }

        static inline string getAbsoluteFilePath(const string& file) { return fileinfo(file).getAbsoluteFilePath(); }

        static inline string getRelativeFilePath(const string& dir, const string& file) { return string(QDir(dir.get()).relativeFilePath(file.get())); }

        static inline string getTempPath() { return string(QDir::tempPath()); }

        static inline string getCwd() { return string(QDir::currentPath()); }

        static inline bool copy(const string& src, const string& dst) {return QFile::copy(src.get(), dst.get());}

        static inline bool exists(const string& file) {return QFile::exists(file.get());}

        static inline bool existsDir(const string& file) {return QDir(file.get()).exists();}

        static inline bool mkdir(const string& file) {return QDir().mkdir(QDir::cleanPath(file.get()));}

        static inline bool remove(const string& file) {return QFile::remove(file.get());}

        static bool rmdir(const string& file, const bool& recursive);

    private:
        QFileInfo _val;
    };


    class file {
    public:
        explicit inline file() {}

        explicit inline file(const z::string& filename) : _val(filename.get()) {}

        inline file(const file& src) : _val(src._val.fileName()) {assert(!src._val.isOpen());}

    public:
        inline QFile& get() { return _val;}

    public:
        inline void setFileName(const z::string& filename) {return _val.setFileName(filename.get());}

        inline string getFileName() const {return string(_val.fileName());}

        inline bool open(int flags) { return _val.open((QIODevice::OpenModeFlag)flags); }

        inline void close() { return _val.close(); }

        inline bool isOpen() const { return _val.isOpen(); }

    private:
        QFile _val;
    };


    class stream {
    public:
        inline stream() {}

        inline stream(const stream& src) {unused(src);}

    public:
        explicit inline stream(const z::string& txt) : _val(&(txt.get())) {}

        explicit inline stream(FILE* file, QIODevice::OpenModeFlag flags) : _val(file, flags) {}

    public:
        inline stream(file& f) : _val(&(f.get())) {}

    public:
        inline QTextStream& get() {return _val;}

    public:
        inline int pos() {return (int)_val.pos();}

        inline bool end() {return _val.atEnd();}

        inline void seek(const int& pos) {_val.seek(pos);}

        inline void flush() {return _val.flush();}

        inline void setDevice(z::file& file) {_val.setDevice(&(file.get()));}

        inline const QString& getString() const {QString* str = _val.string(); assert(str); return *str;}

    public:
        inline int getChar() {
            QChar ch;
            _val >> ch;
            return ch.unicode();
        }

    private:
        QTextStream _val;
    };


    inline z::stream& operator<<(z::stream& ss, const int& val) {
        ss.get() << val;
        return ss;
    }

    inline z::stream& operator<<(z::stream& ss, const char* val) {
        ss.get() << val;
        return ss;
    }

    inline z::stream& operator<<(z::stream& ss, const QString& val) {
        ss.get() << val;
        return ss;
    }

    inline z::stream& operator<<(z::stream& ss, const z::string& val) {
        ss.get() << val.get();
        return ss;
    }

    template<typename derT, typename listT, typename iterT, typename V>
    inline z::stream& operator<<(z::stream& ss, const z::listbase<derT, listT, iterT, V>& val) {
        for(typename derT::iterator it(static_cast<const derT&>(val)); !it.end(); ++it) {
            const V& v = *it;
            ss << v;
        }
        return ss;
    }


    template<typename derT, typename K, typename V>
    inline z::stream& operator<<(z::stream& ss, const z::dictbase<derT, K, V>& val) {
        ss << "{";
        z::string sep;
        for(typename derT::iterator it(static_cast<const derT&>(val)); !it.end(); ++it) {
            const K& k = it.key();
            const V& v = *it;
            ss << sep << k << ":" << v;
            sep = ", ";
        }
        ss << "}";
        return ss;
    }


    class filestream : public stream {
    public:
        explicit filestream() {}

        explicit filestream(file& f) : stream(f) {}

        explicit filestream(FILE* file, QIODevice::OpenModeFlag flags) : stream(file, flags) {}
    };


    class stringstream : public stream {
    public:
        explicit stringstream(const z::string& txt) : stream(txt) {}
    };


    class nullstream : public stream {
    public:
        explicit nullstream() {}
    };

    class end {
    };

    inline z::stream& operator<<(z::stream& ss, const z::end& e) {
        unused(e);
        ss.get() << endl;
        return ss;
    }


    class exception {
    public:
        explicit inline exception(){}

        explicit inline exception(const z::string& msg) : _msg(msg) {
            QTextStream(stderr, QIODevice::WriteOnly) << _msg.get() << endl;
        }

    public:
        inline const z::string& toString() const {return _msg;}

    private:
        z::string _msg;
    };


    class application {
    public:
        inline application(int argc, char* argv[]) {unused(argc); unused(argv);}

    public:
        static inline z::string path() {return z::string(QCoreApplication::applicationDirPath());}

    public:
        static inline z::string getEnv(const z::string& key, const z::string& val = z::string(""))  {
            return z::string(QProcessEnvironment::systemEnvironment().value(key.get(), val.get()));
        }
    };


    class process {
    public:
        inline process(const bool& log, z::stream& ss) : _log(log), _ss(ss) {}

    public:
        inline void addArg(const z::string& arg) {_qargs.append(arg.get());}

        inline void setWorkingDirectory(const z::string& pwd) {_p.setWorkingDirectory(pwd.get());}

        inline z::string getWorkingDirectory() const {return z::string(_p.workingDirectory());}

    private:
        inline void write(bool error) {
            if((!error) && (!_log))
                return;

            if(_p.canReadLine()) {
                z::string s(QString(_p.readAll()));
                if(s.length() > 0) {
                    _ss << s;
                }
            }

            if(_p.exitCode()) {
                _ss << z::string(_p.errorString());
            }
            _ss.flush();
        }

    public:
        inline int execute(const z::string& prog) {
            _p.setProcessChannelMode(QProcess::MergedChannels);
            _p.start(prog.get(), _qargs);

            if(!_p.waitForStarted()) {
                write(true);
                if(_p.exitCode() == 0)
                    return -1;
                return _p.exitCode();
            }

            while(_p.waitForReadyRead(-1)) {
                write(false);
            }

            write(_p.exitCode() != 0);
            return _p.exitCode();
        }

    private:
        QStringList _qargs;

        bool _log;

        z::stream& _ss;

        QProcess _p;
    };


    class timer {
    public:
        explicit inline timer(const bool& start = false) {if(start) {_val.start();}}

    public:
        inline int getElapsed() const {return _val.elapsed();}

    private:
        QTime _val;
    };


    class mutex {
    public:
        explicit inline mutex() {}

    public:
        inline QMutex& get() {return _val;}

    private:
        QMutex _val;
    };


    class mutexlocker {
    public:
        explicit inline mutexlocker(mutex& mx) : _val(&(mx.get())) {}

    private:
        QMutexLocker _val;
    };


    class database {
    public:
        database();

        ~database();

    public:
        bool open(const z::string& type, const z::string& name);

        bool create(const z::string& type, const z::string& name, const char* schema[]);

        inline void close() {return _val.close();}

        inline bool begin() {return _val.transaction();}

        inline bool commit() {return _val.commit();}

        inline bool rollback() {return _val.rollback();}

    public:
        inline QSqlDatabase& get() {return _val;}
    private:
        QSqlDatabase _val;
    };


    class transaction {
    public:
        explicit inline transaction(database& db) : _db(db), _committed(false) {
            _db.begin();
        }

        inline ~transaction() {
            if(!_committed)
                _db.rollback();
        }

        inline void commit() {
            _db.commit();
            _committed = true;
        }

    private:
        database& _db;

        bool _committed;
    };


    class statement {
    public:
        explicit inline statement(database& db, const z::string& sql)  : _db(db), _val(sql.get(), db.get()) {}

    public:
        inline bool next() {return _val.next();}

        inline bool exec() {return _val.exec();}

        inline void finish() {return _val.finish();}

    public:
        int insert();

    public:
        void bind(const z::string& key, const z::any& val);

    public:
        any getVar(const int& idx);

    private:
        database& _db;

        QSqlQuery _val;
    };


    class data : public tree {
    public:
        inline data() : _id(0) {}

    public:
        inline void setId(const int64& id) {assert(_id == 0); assert(id); _id = id;}

        inline const int64& id() const {return _id;}

    private:
        int64 _id;
    };


    class qexpr {
    protected:
        explicit inline qexpr() {}

    public:
        virtual ~qexpr(){}

    public:
        class visitor;

        virtual void visit(visitor& v) const = 0;
    };

    class qid;

    class qint;

    class qstring;

    class qval;

    class qbinary;

    class qnot;

    class qpair;

    class query;

    class qexpr::visitor {
    public:
        virtual void visit(const qval& qe) = 0;

        virtual void visit(const qid& qe) = 0;

        virtual void visit(const qint& qe) = 0;

        virtual void visit(const qstring& qe) = 0;

        virtual void visit(const qbinary& qe) = 0;

        virtual void visit(const qnot& qe) = 0;

        virtual void visit(const qpair& qe) = 0;

        virtual void visit(const query& qe) = 0;
    };


    template <typename T>
    class qvisitorT : public qexpr {
    public:
        explicit inline qvisitorT() {}

    public:
        virtual void visit(qexpr::visitor& v) const {v.visit(static_cast<const T&>(ref(this)));}
    };


    template <typename T, typename qT>
    class qconstant : public qvisitorT< qT > {
    public:
        explicit inline qconstant(const T& val) : _val(val) {}

    private:
        const T& _val;
    };


    class qstring : public qvisitorT<qstring> {
    public:
        explicit inline qstring(const z::string& val) : _val(val) {}

    public:
        inline const z::string& getVal() const {return _val;}

    private:
        const z::string _val;
    };


    class qid : public qvisitorT<qint> {
    public:
        explicit inline qid() : _val(0) {}

        explicit inline qid(const int64& val) : _val(val) {}

    public:
        inline const int64& getVal() const {return _val;}

        inline qid& operator=(const qid& src) {_val = src._val; return ref(this);}

    private:
        int64 _val;
    };


    inline z::stream& operator<<(z::stream& ss, const z::qid& val) {
        ss << val.getVal();
        return ss;
    }


    class qint : public qvisitorT<qint> {
    public:
        explicit inline qint(const int& val) : _val(val) {}

    public:
        inline const int& getVal() const {return _val;}

    private:
        const int _val;
    };


    class qval : public qvisitorT<qval> {
    public:
        explicit inline qval() {}
    };


    class qbinary : public qvisitorT<qbinary> {
    public:
        explicit inline qbinary(const qexpr& lhs, const z::string& op, const qexpr& rhs) : _lhs(lhs), _op(op), _rhs(rhs) {}

    public:
        inline const qexpr& getLhs() const {return _lhs;}

        inline const z::string& getOp() const {return _op;}

        inline const qexpr& getRhs() const {return _rhs;}

    private:
        const qexpr& _lhs;

        const z::string _op;

        const qexpr& _rhs;
    };


    class qnot : public qvisitorT<qnot> {
    public:
        explicit inline qnot(const qexpr& rhs) : _rhs(rhs) {}

    public:
        inline const qexpr& getRhs() const {return _rhs;}

    private:
        const qexpr& _rhs;
    };


    class qpair : public qvisitorT<qpair> {
    public:
        explicit inline qpair(const qexpr& lhs, const qexpr& rhs) : _lhs(lhs), _rhs(rhs) {}

    public:
        inline const qexpr& getLhs() const {return _lhs;}

        inline const qexpr& getRhs() const {return _rhs;}

    private:
        const qexpr& _lhs;

        const qexpr& _rhs;
    };


    class query : public qvisitorT<query> {
    public:
        explicit inline query(const qexpr& expr) : _expr(expr) {}

    public:
        inline const qexpr& getExpr() const {return _expr;}

    private:
        const qexpr& _expr;
    };


    class result : public z::list< z::data > {
    };


    class store {
    public:
        explicit inline store() {}

        explicit inline store(const z::string& path) : _path(path) {}

    public:
        inline store(const store& src) : _path(src._path), _db(src._db) {}

    public:
        inline const string& getPath() const {return _path;}

        inline database& get() {return _db;}

    private:
        string _path;

        database _db;
    };

    inline uint qHash(const z::qid& key) {return qHash(key.getVal());}

    template <typename T>
    inline QVariant getQVar(const T& v) {
        QVariant qv;
        qv.setValue(v);
        return qv;
    }


    class any {
    public:

        class base {
        public:
            virtual ~base(){}

            virtual base* clone() const = 0;

            virtual void write(z::stream& os) const = 0;

            virtual QVariant getVar() const = 0;
        };


        template <typename T>
        class impl : public base {
        public:
            inline impl(const T& val) : _val(val) {}

        public:
            inline const T& get() const {return _val;}

        public:
            virtual base* clone() const {return new impl<T>(_val);}

            virtual void write(z::stream& os) const {
                os << _val;
            }

            virtual QVariant getVar() const {return getQVar<T>(_val);}

        private:
            T _val;
        };

    public:
        inline any() : _val(0) {
            _val = new impl<int>(0);
        }

        inline any(const any& src) : _val(0) {
            _val = ref( src._val).clone();
        }

        inline ~any() {delete _val;}

    public:
        template <typename T>
        explicit inline any(const T& val) : _val(0) {
            _val = new impl<T>(val);
        }

        inline any(const char* val) : _val(0) {
            _val = new impl<z::string>(val);
        }

    public:
        inline any& operator=(const any& src) {
            delete _val;
            _val = ref( src._val).clone();
            return ref(this);
        }

    public:
        virtual void write(z::stream& os) const {
            ref(_val).write(os);
        }

        inline  QVariant getVar() const {return ref(_val).getVar();}

    public:
        template <typename T>
        inline bool is() const {
            impl<T>* p = dynamic_cast<impl<T>*>(_val);
            return (0 != p);
        }

    public:
        template <typename T>
        inline const T& get() const {
            impl<T>* p = dynamic_cast<impl<T>*>(_val);
            if(!p) {
                throw z::exception(z::string::creator("Type mismatch (any)").value());
            }
            return ref(p).get();
        }

    private:
        base* _val;
    };


    inline z::any getVar(const QVariant& v);

    template <>
    inline QVariant getQVar(const z::string& v) {return QVariant(v.get());}


    inline z::stream& operator<<(z::stream& ss, const z::any& val) {
        val.write(ss);
        return ss;
    }


    class key {
    public:
        explicit inline key() {
        }

        inline key(const any& val) : _val(val) {
        }

        inline key(const key& src) : _val(src._val) {
        }

    public:
        inline key& operator=(const z::any& rhs) {
            _val = rhs;
            return ref(this);
        }

    public:
        template <typename T>
        inline key& operator=(const T& rhs) {
            _val = z::any(rhs);
            return ref(this);
        }

    public:
        inline const any& get() const {
            return _val;
        }

    public:
        inline uint getHash() const {
            if(_val.is<int>()) {
                return ::qHash(_val.get<int>());
            }

            if(_val.is<long>()) {
                return ::qHash(_val.get<long>());
            }

            if(_val.is<double>()) {
                return qHash(_val.get<double>());
            }

            if(_val.is<z::string>()) {
                return qHash(_val.get<z::string>());
            }

            throw z::exception(z::string::creator("Unhandled key type: xx").value()); 
        }

    private:
        z::any _val;
    };

    inline bool operator<(const key& lhs, const key& rhs) {
        return lhs.getHash() < rhs.getHash();
    }

    inline uint getTypeHash(const z::string& name, const int64& p) {
        z::string s = z::string::creator("_ztype_%{name}_%{val}_")
                .arg(z::any("name"), z::any(name))
                .arg(z::any("val"), z::any(p))
                .value();

        return ::qHash(s.get());
    }


    inline z::stream& operator<<(z::stream& ss, const z::key& val) {
        val.get().write(ss);
        return ss;
    }

#if !defined(ZEN_NO_GUI)


    class property {
    public:
        inline property(QDeclarativeItem* val, const z::string& idx) : _val(val), _idx(idx) {}

    public:
        inline QVariant getValue() const {
            QVariant v = ref(_val).property(_idx.get().toUtf8().constData());
            if(!v.isValid()) {
                throw z::exception(z::string::creator("Unknown property: %{idx}").arg(z::any("idx"), z::any(_idx)).value());
            }
            return v;
        }

    private:
        inline property& setString(const QString& rhs) {
            ref(_val).setProperty(_idx.get().toUtf8().constData(), rhs);
            return ref(this);
        }

    public:
        inline property& operator=(const z::string& rhs) {
            return setString(rhs.get());
        }

        inline property& operator=(const char* rhs) {
            return setString(QString(rhs));
        }

        inline property& operator=(const z::property& rhs) {
            const QVariant v = rhs.getValue();
            if(v.type() == QVariant::String) {
                return setString(v.toString());
            }
            return ref(this);
        }

    private:
        inline property& appendString(const QString& rhs) {
            QString op = getValue().toString();
            op += rhs;
            ref(_val).setProperty(_idx.get().toUtf8().constData(), op);
            return ref(this);
        }

    public:
        inline property& operator+=(const z::string& rhs) {
            return appendString(rhs.get());
        }

        inline property& operator+=(const char* rhs) {
            return appendString(QString(rhs));
        }

        inline property& operator+=(const z::property& rhs) {
            const QVariant v = rhs.getValue();
            if(v.type() == QVariant::String) {
                return appendString(v.toString());
            }
            return ref(this);
        }

    public:
        inline operator string() const {
            const QVariant v = getValue();
            if(v.type() == QVariant::String) {
                return z::string(v.toString());
            }

            throw z::exception(z::string::creator("Unable to convert property to string: %{idx} type: %{type}").arg(z::any("idx"), z::any(_idx)).arg(z::any("type"), z::any(v.typeName())).value());
        }

    private:
        QDeclarativeItem* _val;

        const z::string _idx;
    };


    class widget {
    public:
        inline widget() : _val(0) {}

        inline widget(QDeclarativeItem* val) : _val(val) {}

        inline widget(const widget& src) : _val(src._val) {}

    public:
        void show() const;

    public:
        inline QDeclarativeItem& get() const {return ref(_val);}

    public:
        inline property operator[](const z::string& idx) const {
            assert(_val);
            return property(_val, idx);
        }
    private:
        QDeclarativeItem* _val;
    };


    class view {
    public:
        inline view() : _val(0) {}

        inline view(const view& src) : _val(src._val) {}

        inline ~view() {}

        inline view& operator=(const view& src) {_val = src._val; return ref(this);}

    public:
        inline view& clear() {delete _val; return ref(this);}

        inline view& set(QDeclarativeView* val) {clear(); _val = val; return ref(this);}

        inline QDeclarativeView& get() {return ref(_val);}

    public:
        inline view& load(const z::string& filename) {
            set(new QDeclarativeView());
            get().setSource(QUrl::fromLocalFile(filename.get()));
            return ref(this);
        }

        inline view& setCallback(const z::string& name, QObject* obj) {
            ref(_val).rootContext()->setContextProperty(name.get(), obj);
            return ref(this);
        }

        inline view& show() {ref(_val).show(); return ref(this);}

    public:
        inline widget operator[](const z::string& idx) const {
            assert(_val);
            QGraphicsObject* rootObject = ref(_val).rootObject();
            QDeclarativeItem* w = rootObject->findChild<QDeclarativeItem*>(idx.get());
            return widget(w);
        }
    private:
        QDeclarativeView* _val;
    };
#endif
}


registerMetatype(z::key);


registerMetatype(z::qid);


registerMetatype(z::tree);

inline z::any z::getVar(const QVariant& v) {
    switch(v.type()) {
        case QVariant::Invalid:
            return z::any();
        case QVariant::Int:
            return z::any(v.toInt());
        case QVariant::LongLong:
            return z::any(v.toLongLong());
        case QVariant::Double:
            return z::any(v.toDouble());
        case QVariant::String:
            return z::any(z::string(v.toString()));
        default:
            break;
    }

    throw z::exception(z::string::creator("Unhandled variant type: %{type}").arg(z::any("type"), z::any(v.typeName())).value());
}


inline QDebug operator<<(QDebug db, const z::any& val) {
    z::string s;
    z::stringstream ss(s);
    ss << val;
    db << s;
    return db;
}

// this string method needs to be defined here because it uses any.
inline z::string::creator& z::string::creator::arg(const z::any& key, const z::any& val) {
    QString keyx = QString("%{%1}").arg(key.get<z::string>().get());
    z::string s;
    z::stringstream ss(s);
    ss << val;
//    QString valx = val.getVar().toString();
//    _val.replace(keyx, valx);
//    qDebug() << "***: keyx =" << keyx << ", _val=" << _val << ", val=" << ss.getString();
    _val.replace(keyx, ss.getString());

    return ref(this);
}


template <typename ToT, typename FromT>
inline ToT* dcast(FromT* from, const z::string& msg) {
    assert(from);
    ToT* to = dynamic_cast<ToT*>(from);
    if(0 == to) {
        throw z::exception(z::string::creator("Error: %{msg}").arg(z::any("msg"), z::any(msg)).value());
    }
    return to;
}


template <typename ToT, typename FromT>
inline ToT& dcast(FromT& from, const z::string& msg) {
    FromT* fromp = ptr(from);
    ToT* to = dcast<ToT, FromT>(fromp, msg);
    assert(to);
    return ref(to);
}