File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/CPP/panda/lib.x/i/panda/function_utils.h

Criterion	Covered	Total	%
statement	24	25	96.0
branch	18	36	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	42	61	68.8

#pragma once

#include
#include

namespace panda {

using panda::shared_ptr;

template
class function;

template
struct Ifunction : virtual public RefCounted {
    virtual ~Ifunction() {}
    virtual Ret operator()(Args...) = 0;
    virtual bool equals(const Ifunction* oth) const = 0;
};

template::value>
struct is_comparable {
    static const bool value = true;
};

template
struct is_comparable {
    struct fallback { bool operator==(const fallback& oth); };
    struct mixed_type: std::remove_reference::type, fallback {};
    template < typename U, U > struct type_check {};

    template < typename U > static std::false_type  test( type_check< bool (fallback::*)(const fallback&), &U::operator== >* = 0 );
    template < typename U > static std::true_type   test( ... );

    static const bool value = std::is_same(nullptr)), std::true_type>::value;
};


template
struct has_call_operator {
private:
    typedef std::true_type yes;
    typedef std::false_type no;

    template static auto test(int) -> decltype(std::declval()(std::declval()...), yes());
    template static no test(...);

public:
    static constexpr bool value = std::is_same(0)),yes>::value;
};


template
class abstract_function {};

template
class callable {};

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

    Ret operator()(Self&, Args... args) {
        return func(args...);
    }
protected:
    typename std::remove_reference::type func;
};

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

    Ret operator()(Self& self, Args... args) {
        return func(self, args...);
    }
protected:
    typename std::remove_reference::type func;
};


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

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

    bool equals(const Ifunction* oth) const override {
        auto foth = dynamic_cast(oth);
        if (foth == nullptr) {
            return false;
        }

        return func == foth->func;
    }

    typename std::remove_reference::type func;
};

template
class abstract_function : public Ifunction
        , public callable::value, Ifunction, Args...>
{
public:
    using Derfed = typename std::remove_reference::type;
    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 Ifunction* oth) const override {
        return static_cast*>(this) == oth;
    }

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

//    template
//    Ret call(Args... args) {
//       return (this->template func.*meth)(10, args...);
//    }
};


template
class abstract_function : public Ifunction {
public:
    using Func = Ret (*)(Args...);
    explicit abstract_function(const Func& f) : func(f) {}

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

    bool equals(const Ifunction* oth) const override {
        auto foth = dynamic_cast(oth);
        if (foth == nullptr) return false;

        return func == foth->func;
    }

    Ret (*func)(Args...);
};

template
auto make_abstract_function(Ret (*f)(Args...)) -> shared_ptr> {
    return panda::make_shared>(f);
}

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

template
          typename Functor, bool IsComp = is_comparable::type>::value,
          typename DeFunctor = typename std::remove_reference::type,
          typename Check = decltype(std::declval()(std::declval()...)),
          typename = typename std::enable_if::value>::type>
shared_ptr> make_abstract_function(Functor&& f, Check(*)() = 0) {
    return panda::make_shared>(std::forward(f));
}

template
          typename Functor, bool IsComp = is_comparable::type>::value,
          typename DeFunctor = typename std::remove_reference::type,
          typename Check = decltype(std::declval()(std::declval()...)),
          typename = typename std::enable_if::value>::type>
abstract_function tmp_abstract_function(Functor&& f, Check(*)() = 0) {
    return abstract_function(std::forward(f));
}

template
          typename Functor, bool IsComp = is_comparable::type>::value,
          typename DeFunctor = typename std::remove_reference::type,
          typename Check = decltype(std::declval()(std::declval&>(), std::declval()...))>
shared_ptr> make_abstract_function(Functor&& f) {
    return panda::make_shared>(std::forward(f));
}

template
          typename Functor, bool IsComp = is_comparable::type>::value,
          typename DeFunctor = typename std::remove_reference::type,
          typename Check = decltype(std::declval()(std::declval&>(), std::declval()...))>
abstract_function tmp_abstract_function(Functor&& f) {
    return abstract_function(std::forward(f));
}

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

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

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

    bool equals(const ifunction* oth) const override {
        auto moth = dynamic_cast*>(oth);
        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:
    shared_ptr thiz;
    Method meth;
};

template
inline shared_ptr> make_method(Ret (Class::*meth)(Args...), shared_ptr thiz = nullptr) {
    return panda::make_shared>(meth, thiz);
}

template
inline shared_ptr> make_abstract_function(Ret (Class::*meth)(Args...), shared_ptr thiz = nullptr) {
    return panda::make_shared>(meth, thiz);
}

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