File Coverage

src/panda/function_utils.h

Criterion	Covered	Total	%
statement	44	47	93.6
branch	250	500	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	294	547	53.7

#pragma once
#include "refcnt.h"
#include "traits.h"
#include

namespace panda {

template
class function;

namespace function_details {
    struct AnyFunction {
        virtual ~AnyFunction() {}

        virtual const AnyFunction* get_base() const {
            return this;
        }
    };
}


template
struct Ifunction : function_details::AnyFunction, virtual Refcnt {
    virtual ~Ifunction() {}
    virtual Ret operator()(Args...) = 0;
    virtual bool equals(const function_details::AnyFunction* oth) const = 0;
};

namespace function_details {

template
class abstract_function {};

template
class storage {
public:
    template
    explicit storage(F&& f) : func(std::forward(f)) {}

    std::remove_reference_t func;
};

template
class callable {};

template
class callable : public storage
{
public:
    template
    explicit callable(F&& f) : storage(std::forward(f)) {}

    Ret operator()(Self&, Args... args) {
        return this->func(args...);
    }
};


template
class callable : public storage
{
public:
    template
    explicit callable(F&& f) : storage(std::forward(f)) {}

    Ret operator()(Self& self, Args... args) {
        return this->func(self, args...);
    }
};

template
class abstract_function : public Ifunction, public storage {
public:
    template
    explicit abstract_function(F&& f) : storage(std::forward(f)) {}

    Ret operator()(Args... args) override {
        static_assert(std::is_convertiblefunc(args...)), Ret>::value, "return type mismatch");
        return this->func(args...);
    }

    bool equals(const AnyFunction* oth) const override {
        auto foth = dynamic_cast*>(oth->get_base());
        if (foth == nullptr) {
            return false;
        }

        return this->func == foth->func;
    }
};

template
class abstract_function : public Ifunction
        , public callable::value, Ifunction, Args...>
{
public:
    using Derfed = std::remove_reference_t;
    using Caller = callable::value, Ifunction, Args...>;

    template
    explicit abstract_function(F&& f) : Caller(std::forward(f)) {}

    Ret operator()(Args... args) override {
        return Caller::operator()(*this, args...);
    }

    bool equals(const AnyFunction* oth) const override {
        return this->get_base() == oth->get_base();
    }

private:
    template
    Ret call(Args... args) {
       return (this->template func.*meth)(args...);
    }
};


template
class abstract_function : public Ifunction, public storage {
public:
    using Func = FRet (*)(FArgs...);
    explicit abstract_function(const Func& f) : storage(f) {}

    Ret operator()(Args... args) override {
        return this->func(args...);
    }

    bool equals(const AnyFunction* oth) const override {
        auto foth = dynamic_cast*>(oth->get_base());
        if (foth == nullptr) return false;

        return this->func == foth->func;
    }
};

template
struct function_caster : public Ifunction {
    From src;
    using Check = std::is_base_of;

    function_caster(From src) : src(src) {}

    Ret operator()(Args... args) override {
        return src->operator()(args...);
    }

    bool equals(const function_details::AnyFunction* oth) const override {
        return src->equals(oth);
    }

    const AnyFunction* get_base() const override {
        return src->get_base();
    }


};

template
struct is_panda_function_t {
    static constexpr bool value = false;
};

template
struct is_panda_function_t> {
    static constexpr bool value = true;
};

template
auto make_abstract_function(Ret (*f)(Args...)) -> iptr> {
    if (!f) return nullptr;
    return new abstract_function(f);
}

template
auto tmp_abstract_function(Ret (*f)(Args...)) -> abstract_function {
    assert(f);
    return abstract_function(f);
}

template
          bool IsComp = is_comparable>::value,
          typename DeFunctor = std::remove_reference_t,
          typename = std::enable_if_t&, Args...>::value ||
                                      has_call_operator::value>,
          typename = std::enable_if_t::value>,
          typename = std::enable_if_t::value>>
iptr> make_abstract_function(Functor&& f) {
    if (!bool_or(f, true)) return nullptr;
    return new abstract_function(std::forward(f));
}

template
          bool IsComp = is_comparable>::value,
          typename DeFunctor = std::remove_reference_t,
          typename = std::enable_if_t&, Args...>::value ||
                                      has_call_operator::value>,
          typename = std::enable_if_t::value>,
          typename = std::enable_if_t::value>>
abstract_function tmp_abstract_function (Functor&& f) {
    assert(bool_or(f, true));
    return abstract_function(std::forward(f));
}

template
          typename = std::enable_if_t, Args...>::value>>
auto make_abstract_function(const function& func) -> iptr> {
    if (!func) return nullptr;
    return new function_caster(func.func);
}


template
struct method : public Ifunction{
    using Method = Ret (Class::*)(Args...);
    using ifunction = Ifunction;

    method(Method method, iptr thiz = nullptr) : thiz(thiz), meth(method) {}
    iptr bind(iptr thiz) {
        this->thiz = thiz;
        return iptr(this);
    }

    Ret operator()(Args... args) override {
        return (thiz.get()->*meth)(std::forward(args)...);
    }

    bool equals(const AnyFunction* oth) const override {
        auto moth = dynamic_cast*>(oth->get_base());
        if (moth == nullptr) return false;

        return operator ==(*moth);
    }

    bool operator==(const method& oth) const {
        return thiz == oth.thiz && meth == oth.meth;
    }

    bool operator !=(const method& oth) const {
        return !operator ==(oth);
    }

    explicit operator bool() const {
        return thiz && meth;
    }

private:
    iptr thiz;
    Method meth;
};

template
inline iptr> make_method(Ret (Class::*meth)(Args...), iptr thiz = nullptr) {
    if (!meth) return nullptr;
    return new method(meth, thiz);
}

template
inline iptr> make_abstract_function(Ret (Class::*meth)(Args...), iptr thiz = nullptr) {
    if (!meth) return nullptr;
    return new method(meth, thiz);
}

template
inline method tmp_abstract_function(Ret (Class::*meth)(Args...), iptr thiz = nullptr) {
    assert(meth);
    return method(meth, thiz);
}
}

}