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

Go to the documentation of this file.

#pragma once

#include "zrt.hpp"

namespace ztl {

    template <typename ReturnT>
    class ClosureT : public zbl::Closure {
    protected:
        inline ClosureT(){}

    private:
        inline ClosureT(const ClosureT& src) {unused(src);}

    public:
        inline ReturnT& getValue() {return *_val;}

        inline void setValue(const ReturnT& val) {_val.reset(new ReturnT(val));}

    private:
        z::scopedptr<ReturnT> _val;
    };


    template <typename ReturnT>
    class FunctionCallClosureT : public ClosureT<ReturnT> {
    };


    class SharedClosureT : public zbl::Closure {
    protected:
        inline SharedClosureT(){}

    private:
        inline SharedClosureT(const SharedClosureT& src) {unused(src);}
    };


    class LoopClosureT : public zbl::Closure {
    protected:
        inline LoopClosureT(){}

    private:
        inline LoopClosureT(const LoopClosureT& src) {unused(src);}
    };


    template <typename ReturnT>
    class ReturnClosureT : public ClosureT<ReturnT> {
    protected:
        inline ReturnClosureT(){}
    };


    template <typename ReturnT>
    class ContinuationT : public zbl::Continuation {
    public:
        typedef z::scopedptr<ContinuationT> Ptr;
    protected:
        inline ContinuationT() : Continuation(), _parent(0) {}

        inline ContinuationT(const ContinuationT& src) : Continuation(src), _parent(0) {}

    public:
        inline void setParent(ClosureT<ReturnT>& parent) {_parent = ptr(parent);}

    private:
        virtual void setParent(zbl::Closure* parent) {
            ClosureT<ReturnT>* p = dynamic_cast< ClosureT<ReturnT>* >(parent);
            assert(p);
            ref(this).setParent(ref(p));
        }

    public:
        inline ContinuationT<ReturnT>* cloneT() const {
            zbl::Continuation::Ptr continuation;
            clone(continuation);
            return dynamic_cast<ContinuationT<ReturnT>* >(continuation.take());
        }

#ifdef TRACE_RUN
    private:
        virtual zbl::Closure* getParent() const {return _parent;}
#endif

    public:
        inline void setReturn(const ReturnT& val) {
            if(_parent)
                ref(_parent).setValue(val);
        }

    private:
        ClosureT<ReturnT>* _parent;
    };


    template <typename ReturnT>
    class ContinuationListT : public z::queue<ztl::ContinuationT<ReturnT>*> {
    public:
        inline ~ContinuationListT();

    public:
        inline void take(ContinuationListT<ReturnT>& src);
    };


    template <typename ReturnT>
    class RunContextT {
    public:
        inline RunContextT(zbl::Engine& engine) : _engine(engine) {}

    public:
        inline ContinuationT<ReturnT>& append(ContinuationT<ReturnT>* continuation) {
            _continuationList.append(continuation);
            return ref(continuation);
        }

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

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

        inline void getContinuation(typename ztl::ContinuationT<ReturnT>::Ptr& continuation) {continuation.reset(_continuationList.deque());}

    private:
        zbl::Engine& _engine;

        ztl::ContinuationListT<ReturnT> _continuationList;
    };


    template <typename srcT, typename rtnT, typename ctxT, typename contT>
    inline void adaptFunction(contT& cont, typename srcT::Impl::RunCtx& src, ctxT& dstCtx) {
        while(src.hasContinuation()) {
            typename ztl::ContinuationT<rtnT>::Ptr childSeq;
            src.getContinuation(childSeq);
            z::scopedptr<contT> parentSeq(new contT(cont));
            childSeq->setParent(parentSeq->getFCall());
            parentSeq->setChild(childSeq.take());
            dstCtx.append(parentSeq.take());
        }
    }


    template <typename srcT, typename rtnT>
    inline void adaptClosure(typename srcT::Impl::RunCtx& src, zbl::RunContext& dstCtx) {
        while(src.hasContinuation()) {
            typename ztl::ContinuationT<rtnT>::Ptr childSeq;
            src.getContinuation(childSeq);
            dstCtx.append(childSeq.take());
        }
    }


    template <typename srcT, typename rtnT>
    inline void adaptNative(typename srcT::Impl::RunCtx& src) {
        zbl::RunContext rctx(src.getEngine());
        adaptClosure<srcT, rtnT>(src, rctx);
        src.getEngine().enque(rctx);
    }


    template <typename T, typename ImplT>
    class TestFactoryT : public zbl::TestFactory {
    private:
        class TcontinuationT : public ContinuationT<int> {
        private:
            class _C_test : public FunctionCallClosureT<typename T::Return> {
            public:

                inline _C_test(const z::string& name) : _name(name) {}

            private:
                zbl::Linker _runner;

                virtual zbl::Runner& getRunner() {return _runner;}

#ifdef TRACE_RUN
            private:
                virtual void trace(z::stream& os) const {
                    os << "name=\"TestFactoryT::TcontinuationT::TClosure\", test=\"" << _name << "\"";
                }
#endif

                virtual zbl::Closure::Action::T runClosureWithCtx(zbl::RunContext& _ctx) {
                    typename ImplT::RunCtx _pctx(_ctx.getEngine());
                    ImplT fcall;
                    typename T::Return rv = fcall.run(_pctx);
                    setValue(rv);
                    ztl::adaptClosure<T, typename T::Return>(_pctx, _ctx);
                    return zbl::Closure::Action::Next;
                }

            public:
                const z::string& _name;
            };

        private:
            class _C_rtn : public ReturnClosureT<int> {
            public:
                inline _C_rtn(const z::string& name, zbl::TestResult& tr, _C_test& p_x) : _name(name), _tr(tr), x(p_x) {}

            private:
                zbl::Linker _runner;

                virtual zbl::Runner& getRunner() {return _runner;}

#ifdef TRACE_RUN
            private:
                virtual void trace(z::stream& os) const {
                    os << "name=\"TestFactoryT::TcontinuationT::RClosure\", test=\"" << _name << "\"";
                }
#endif

                virtual Action::T runClosureWithCtx(zbl::RunContext& _ctx) {
                    unused(_ctx);
                    _tr.add(_name, x.getValue().passed);
                    return Action::Next;
                }
            public:
                const z::string& _name;

                zbl::TestResult& _tr;

                _C_test& x;
            };

            virtual void clone(zbl::Continuation::Ptr& continuation) const {
                continuation.reset(new TcontinuationT(*this));
            }

        private:
            _C_test _test;

            _C_rtn  _rtn;

        private:
            inline void init() {_closureList << ptr(_test) << ptr(_rtn);}

        public:
            inline TcontinuationT(const z::string& name, zbl::TestResult& tr) : ContinuationT<int>(), _test(name), _rtn(name, tr, _test) {init();}

            inline TcontinuationT(const TcontinuationT& src) : ContinuationT<int>(src), _test(src._rtn._name), _rtn(src._rtn._name, src._rtn._tr, _test) {init();}
        };

    public:
        inline TestFactoryT(const z::string& name) : TestFactory(name) {}

    private:
        virtual zbl::Continuation* get() const {return new TcontinuationT(_name, ref(_tr));}
    };
}

template <typename rtnT>
inline ztl::ContinuationListT<rtnT>::~ContinuationListT() {
    // The list should be empty at dtor time...
    if(ref(this).size() != 0) {
        throw z::exception(z::string::creator("Internal error: ContinuationListT should be empty in dtor").value());
    }
    // but delete any remaining ones in Release build.
    while(ref(this).size() > 0) {
    }
}

template <typename rtnT>
inline void ztl::ContinuationListT<rtnT>::take(ContinuationListT<rtnT>& src) {
    while(src.size() > 0) {
        zbl::Continuation::Ptr ptr(src.deque());
        ref(this).append(ptr.take());
    }
}