File Coverage

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

Criterion	Covered	Total	%
statement	14	14	100.0
branch	10	16	62.5
condition			n/a
subroutine			n/a
pod			n/a
total	24	30	80.0

#pragma once

#include
#include
#include "function_utils.h"

namespace panda {

using panda::shared_ptr;
using panda::make_shared;
using std::remove_reference;

template
class function;

template
class function {
public:
    using Func = shared_ptr>;
    Func func;

public:
    function(){}
    function(std::nullptr_t){}

    template
    function(const shared_ptr& f) : func(f) {}

    template
             typename = decltype(make_abstract_function(std::declval()...)),
             typename = typename std::enable_if::value>::type>
    function(F&&... f)
        : func(make_abstract_function(std::forward(f)...))
    {}



    function(Func func) : func(func) {};

    function(const function& oth) = default;
    function(function&& oth) = default;

    function& operator=(const function& oth) = default;
    function& operator=(function&& oth) = default;

    Ret operator ()(Args... args) const {return func->operator ()(std::forward(args)...);}
    bool operator ==(const function& oth) const {
        return (func && func->equals(oth.func.get())) || (!func && !oth.func);
    }
    bool operator !=(const function& oth) const {return !operator ==(oth);}

    bool operator ==(const Ifunction& oth) const {
        return func && func->equals(&oth);
    }
    bool operator !=(const Ifunction& oth) const {return !operator ==(oth);}

    explicit operator bool() const {
        return func;
    }
};

template
class function : public function{
public:
    using function::function;
    using ArgsTuple = std::tuple;
    using RetType = Ret;
};

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

template
inline function make_function(Ret (*f)(Args...)) {
    return function(f);
}

}