binder.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "memlite/binder/tbindable.hpp"
 
struct binderTest;
 
namespace by {
 
    class bindTacticable;
    class life;
 
    class _nout binder: public typeProvidable, public tbindable<instance> {
        BY(ME(binder, instance), INIT_META(me))
        friend class memliteInternal;
        friend struct ::binderTest;
 
    public:
        binder(const type& type, bindTacticable& tactic);
        binder(const me& rhs);
        virtual ~binder();
 
    public:
        instance* operator->();
        const instance* operator->() const BY_CONST_FUNC(operator->())
        instance& operator*();
        const instance& operator*() const BY_CONST_FUNC(operator*())
        me& operator=(const me& rhs);
 
    public:
        //  binder:
        id getItsId() const;
        //  tbindable:
        nbool isBind() const override;
        void rel() override;
        using tbindable::canBind;
 
        nbool canBind(const type& it) const override;
        using tbindable::bind;
 
        nbool bind(const instance& it) override;
 
        instance* get();
        const instance* get() const BY_CONST_FUNC(get())
 
        template <typename E> E* get() { return get()->template cast<E>(); }
        template <typename E> const E* get() const BY_CONST_FUNC(get<E>())
 
        //  typeProvidable:
        const type& getType() const override;
 
        using typeProvidable::cast;
        void* cast(const type& to) override;
 
    protected:
        nbool _assign(const binder& rhs);
 
        nbool _onSame(const typeProvidable& rhs) const override;
 
        life* _getBindTag() const;
 
    protected:
        id _itsId; // id for binded one
        const type* _type;
        bindTacticable* _tactic;
    };
 
    // extension for OR macro:
    template <typename F> tmedium<instance> operator|(binder& t, F&& f) {
        f(t);
        // this returns null-reference but take it easy.
        // it'll never be used.
        return t.get();
    }
 
    template <typename F> tmedium<instance> operator|(const binder& t, F&& f) {
        f(t);
        // this returns null-reference but take it easy.
        // it'll never be used.
        return t.get();
    }
 
    // extension for typeTrait:
    template <> struct typeTrait<binder> {
        typedef binder Org;
        typedef binder& Ref;
        typedef binder* Ptr;
 
        static nbool isNul(const binder& it) { return !it.isBind(); }
 
        static constexpr nbool is_ptr = false;
        static constexpr nbool is_ref = false;
        static constexpr nbool is_like_ptr = true;
    };
 
    template <> struct typeTrait<binder*> {
        typedef binder Org;
        typedef binder& Ref;
        typedef binder* Ptr;
 
        static binder* ret() { return nullptr; }
 
        static nbool isNul(const binder* it) { return !it || !it->isBind(); }
 
        static constexpr nbool is_ptr = true;
        static constexpr nbool is_ref = false;
        static constexpr nbool is_like_ptr = is_ptr;
    };
 
    template <> struct typeTrait<binder&> {
        typedef binder Org;
        typedef binder& Ref;
        typedef binder* Ptr;
 
        static nbool isNul(const binder& it) { return it.isBind(); }
 
        static constexpr nbool is_ptr = false;
        static constexpr nbool is_ref = true;
        static constexpr nbool is_like_ptr = true;
    };
 
    // extension for TO macro:
    template <typename T, typename F> auto operator->*(binder* t, F&& f) {
        return t ? f(**t) : typeTrait<std::decay_t<decltype(f(**t))>>::ret();
    }
 
    template <typename T, typename F> auto operator->*(const binder* t, F&& f) {
        return t ? f(**t) : typeTrait<std::decay_t<decltype(f(**t))>>::ret();
    }
 
    template <typename T, typename F> auto operator->*(binder& t, F&& f) {
        return t ? f(*t) : typeTrait<std::decay_t<decltype(f(*t))>>::ret();
    }
} // namespace by