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

Go to the documentation of this file.

#pragma once

//#define TRACE_RUN
//#define TRACE_JOIN

#ifdef TRACE_RUN

#define TRACE_FUNCTION(s) zbl::Tracer _t_(z::string(s));unused(_t_)
#else

#define TRACE_FUNCTION(s)
#endif

namespace zbl {

    z::stream& dlog();

    z::stream& mlog();

    z::stream& wlog();

    z::stream& elog();


    class Tracer {
    public:
        inline Tracer(const z::string& fname) : _fname(fname) {qDebug() << ">" << _fname;}

        inline ~Tracer() {qDebug() << "<" << _fname;}

    private:
        const z::string _fname;
    };


    class Runner {
    protected:
        inline Runner(){}

    public:
        virtual ~Runner(){}

    public:
        virtual bool enterRun() = 0;

        virtual bool leaveRun() = 0;
    };


    class Linker : public Runner {
    public:
        inline Linker(){}

        virtual ~Linker(){}

    private:
        virtual bool enterRun();

        virtual bool leaveRun();
    };


    class Joiner : public Runner {
    public:
        Joiner();

        Joiner(const Joiner& src);

        virtual ~Joiner();

#if defined(TRACE_RUN) || defined(TRACE_JOIN)
    public:
        virtual void trace(z::stream& os, const z::string& fn) const;

        inline void trace(z::stream& os) const {
            trace(os, z::string(""));
        }
#endif
    public:
        virtual bool enterRun();

        virtual bool leaveRun();

    private:
        class Impl;

        Impl* _impl;
    };


    class RunContext;


    class Closure {
    public:
        struct Action {
            enum T {
                Noop, 
                Next, 
                Loop, 
            };
        };

    protected:
        inline Closure() {}

    public:
        virtual Runner& getRunner() = 0;

    public:
        virtual Action::T runClosureWithCtx(zbl::RunContext& _ctx) = 0;

#ifdef TRACE_RUN
    public:
        virtual void trace(z::stream& os) const = 0;

        inline void trace(const z::string& level, z::stream& os) const {
            os << level << "C:{this:" << this << ", ";
            //os << "type:" << typeid(ref(this)).name() << ", ";
            trace(os);
            os << "}" << endl;
        }
#endif
    };


    class Continuation {
    public:
        typedef z::scopedptr<zbl::Continuation> Ptr;

        typedef z::list<Runner*> JoinerList;

    protected:
        inline Continuation() : _idx(0), _child(0) {
        }

        inline Continuation(const Continuation& src) : _idx(src._idx), _child(0) {
        }

    public:
        virtual ~Continuation() {
        }

    public:
        inline bool goNext(const Closure::Action::T& action);

        inline Closure& getCurrentClosure();

    public:
        virtual void setParent(Closure* parent) = 0;

#ifdef TRACE_RUN
    private:
        virtual Closure* getParent() const = 0;

    public:
        inline void trace(const z::string& level, z::stream& os) const {
            os << level << "S:{this=" << this << ", idx=" << _idx << ", parent=" << getParent() << "}" << endl;
            for(z::list<Closure*>::iterator it(_closureList); !it.end(); ++it) {
                ref(*it).trace(level + "  ", os);
            }
        }
#endif
    public:
        Closure::Action::T run(zbl::RunContext& _ctx);

    public:
        virtual void clone(zbl::Continuation::Ptr& continuation) const = 0;

    public:
        inline bool hasChild() {return (0 != _child);}

        inline void setChild(Continuation* child) {
            assert(_child == 0);
            _child = child;
        }

        inline void getChild(zbl::Continuation::Ptr& continuation) {
            continuation.reset(_child);
            _child = 0;
        }

    public:
        inline JoinerList& getJoinerList() {return _joinerList;}

    protected:
        int _idx;

        z::list<Closure*> _closureList;

        JoinerList _joinerList;

    private:
        Continuation* _child;
    };


    class ContinuationList : public z::queue<zbl::Continuation*> {};


    class Engine;


    class RunContext {
    public:
        inline RunContext(Engine& engine) : _engine(engine) {}

    private:
        inline RunContext(const RunContext& src) : _engine(src._engine) {}

    public:
        inline zbl::Engine& getEngine() {return _engine;}

        inline void append(Continuation* continuation) {_list.append(continuation);}

        inline bool hasContinuation() {return (_list.size() > 0);}

        inline void getContinuation(zbl::Continuation::Ptr& continuation) {continuation.reset(_list.deque());}

    private:
        Engine& _engine;

        ContinuationList _list;
    };


    class Fiber {
    public:
        typedef z::scopedptr<Fiber> Ptr;

    public:
        inline Fiber() {
        }

        inline ~Fiber() {
            if(_continuationList.size() > 0) {
                throw z::exception(z::string::creator("Internal error: _continuationList should be empty in Fiber::dtor").value());
            }
        }

    public:
        zbl::Closure::Action::T run(zbl::RunContext& _ctx);

        bool next(const Closure::Action::T& action);

        void clone(zbl::Fiber::Ptr& fiber) const;

#ifdef TRACE_RUN
    public:
        inline void trace(const z::string& level, z::stream& os) const {
            os << level << "F:{this=" << this << "}" << endl;
            for(z::stack<Continuation*>::iterator it(_continuationList); !it.end(); ++it) {
                ref(*it).trace(level + "  ", os);
            }
        }
#endif

    public:
        Continuation* pushContinuation(Continuation::Ptr& continuation);

        bool popContinuation(Continuation::Ptr& continuation);

        Continuation* addContinuation(Continuation::Ptr& continuation);

    private:
        z::stack<Continuation*> _continuationList;
    };


    class TestResult {
    public:
        inline TestResult() : _passed(0), _total(0) {}

    public:
        void add(const z::string& name, const int& passed);

        void writeSummary();

    private:
        z::dict<z::string, int> _result;

    private:
        int _passed;

        int _total;
    };


    class TestFactory {
    protected:
        inline TestFactory(const z::string& name) : _tr(0), _name(name), _next(0) {
            _next = _head;
            _head = this;
        }

    public:
        inline void setTestResult(TestResult& tr) {_tr = ptr(tr);}

    public:
        inline const z::string& getName() const {return _name;}

    public:
        virtual Continuation* get() const = 0;

    protected:
        TestResult* _tr;

        const z::string _name;

    public:
        static TestFactory* _head;

        TestFactory* _next;
    };


    class Engine {
    public:
        enum Mode {
            mNone,  
            mHelp,  
            mRun,   
            mTest,  
        };

    public:
        Engine(int argc, char* argv[]);

        ~Engine();

    public:
        const Mode& getMode() const;

    public:
        int init(int argc, char* argv[]);

        int exit();

        int pump();

    public:
        void enque(RunContext& ctx);

        void registerOnExit(Continuation* continuation);

    private:
        class Impl;

        Impl* _impl;
    };
}