node.hpp

이 파일의 문서화 페이지로 가기

 
#pragma once
 
#include "core/builtin/container/native/tnarr.hpp"
#include "core/frame/frameInteractable.hpp"
#include "core/type/ntype.hpp"
#include "core/builtin/container/native/tnmap.hpp"
#include "core/ast/tpriorities.hpp"
#include "core/ast/validable.hpp"
 
namespace by {
 
    class ases;
    class args;
    class visitor;
    class visitInfo;
    class baseObj;
    class src;
    class modifier;
    template <typename K, typename V, typename defaultContainer> class tnchain;
 
    typedef tnchain<std::string, node, tnmap<std::string, node, immutableTactic>> scope;
 
    template <typename T> class tmock;
 
    class _nout node: public instance, public frameInteractable {
        BY(ADT(node, instance))
        friend class coreInternal;
 
    public:
        me& operator[](const std::string& name);
        const me& operator[](const std::string& name) const BY_CONST_FUNC(operator[](name));
        me& operator[](const std::string* it);
        const me& operator[](const std::string* it) const BY_CONST_FUNC(operator[](it));
        me& operator[](const nchar* name);
        const me& operator[](const nchar* name) const BY_CONST_FUNC(operator[](name));
 
    public:
        nbool in(const node& elem) const;
        nbool in(const node* elem) const;
 
        virtual scope& subs() = 0;
        const scope& subs() const BY_CONST_FUNC(subs())
        virtual tstr<nbicontainer> mySubs() const;
 
        const node* promote(const node& it) const;
        const node* promote(const node* it) const BY_SIDE_FUNC(promote);
 
        template <typename T> T* sub(std::function<nbool(const std::string&, const T&)> l);
        template <typename T>
        const T* sub(std::function<nbool(const std::string&, const T&)> l) const BY_CONST_FUNC(sub<T>(l))
        template <typename T = me> T* sub();
        template <typename T = me> const T* sub() const BY_CONST_FUNC(sub<T>())
        template <typename T = me> T* sub(const std::string& name);
        template <typename T = me> T* sub(const std::string* it) BY_SIDE_FUNC(sub);
        template <typename T = me> const T* sub(const std::string& name) const BY_CONST_FUNC(sub<T>(name))
        template <typename T = me> const T* sub(const std::string* name) const BY_CONST_FUNC(sub<T>(name))
        template <typename T = me> T* sub(const std::string& name, const args& a);
        template <typename T = me>
        T* sub(const std::string* name, const args& a) BY_SIDE_FUNC(name, sub(*name, a), nullptr);
        template <typename T = me>
        const T* sub(const std::string& name, const args& a) const BY_CONST_FUNC(sub<T>(name, a))
        template <typename T = me>
        const T* sub(const std::string* name, const args& a) const BY_CONST_FUNC(sub<T>(name, a))
 
        template <typename T> tnarr<T, strTactic> subAll(std::function<nbool(const std::string&, const T&)> l) const;
        template <typename T = me> tnarr<T, strTactic> subAll() const;
        template <typename T = me> tpriorities<T> subAll(const std::string& name) const;
        template <typename T = me>
        tpriorities<T> subAll(const std::string* it) const BY_SIDE_FUNC(subAll<T>)
 
 
            template <typename T = me>
            tpriorities<T> subAll(const std::string& name, const args* a) const;
        template <typename T = me> tpriorities<T> subAll(const std::string& name, const args& a) const;
        template <typename T = me>
        tpriorities<T> subAll(const std::string* name, const args* a) const
            BY_SIDE_FUNC(name, subAll<T>(*name, a), tpriorities<T>());
        template <typename T = me>
        tpriorities<T> subAll(const std::string* name, const args& a) const
            BY_SIDE_FUNC(name, subAll<T>(*name, a), tpriorities<T>());
 
        bool canEval(const args& a) const;
        virtual priorType prioritize(const args& a) const = 0;
        priorType prioritize(const args* it) const BY_SIDE_FUNC(it, prioritize(*it), NO_MATCH);
 
        virtual str eval(const args& a) = 0;
        str eval(const args* it) BY_SIDE_FUNC(eval);
        str eval(const std::string& name, const args& a);
        str eval(const std::string& name, const args* a) BY_SIDE_FUNC(a, eval(name, a), str());
        str eval(const std::string* name, const args& a) BY_SIDE_FUNC(name, eval(*name, a), str());
        str eval(const std::string* name, const args* a) BY_SIDE_FUNC(name&& a, eval(*name, *a), str());
        str eval(const std::string& name);
        str eval(const std::string* it) BY_SIDE_FUNC(eval);
        str eval();
 
        virtual void rel() {}
 
        template <typename T> nbool is() const { return is(ttype<T>::get()); }
 
        nbool is(const typeProvidable& to) const;
        nbool is(const typeProvidable* it) const BY_SIDE_FUNC(is);
        nbool is(const type& to) const;
        nbool is(const type* it) const BY_SIDE_FUNC(is);
 
        template <typename T> tstr<T> as() const { return as(ttype<T>::get()); }
 
        str as(const typeProvidable& to) const;
        str as(const typeProvidable* it) const BY_SIDE_FUNC(as);
        str as(const type& to) const;
        str as(const type* it) const BY_SIDE_FUNC(as);
 
        template <typename T> nbool isImpli() const { return isImpli(ttype<T>::get()); }
 
        virtual nbool isImpli(const type& to) const;
        nbool isImpli(const typeProvidable& to) const;
        nbool isImpli(const typeProvidable* it) const BY_SIDE_FUNC(isImpli);
 
        template <typename T> tstr<T> asImpli() const { return asImpli(ttype<T>::get()); }
 
        virtual str asImpli(const type& to) const;
        str asImpli(const typeProvidable& to) const;
        str asImpli(const typeProvidable* it) const BY_SIDE_FUNC(asImpli);
 
        virtual const src& getSrc() const;
 
        virtual nbool isComplete() const;
 
        virtual str infer() const;
 
        virtual void accept(const visitInfo& i, visitor& v);
 
        using frameInteractable::inFrame;
        void inFrame(const bicontainable* args) const override;
        using frameInteractable::outFrame;
        void outFrame() const override;
 
        virtual const modifier& getModifier() const;
 
    protected:
        virtual str _onEvalSub(node& sub, const args& a);
        virtual void _setSrc(const src& s);
        void _setSrc(const src* it) BY_SIDE_FUNC(_setSrc);
    };
 
    extern template class tnmap<std::string, node>;
    typedef tnmap<std::string, node> nmap;
} // namespace by