File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/XS/libpanda.x/i/panda/traits.h

Criterion	Covered	Total	%
statement	2	2	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	2	2	100.0

#pragma once
#include

namespace panda {

namespace detail {
    template  struct bool_pack {};
}

/// bool_or returns its first argument converted to bool if it is possible, or default value (second arg) if type is not convertible to bool
template
inline bool bool_or (T&& val, decltype(bool(val))) {
    return bool(val);
}

template ::value>::type>
inline bool bool_or (T&&, bool default_val) {
    return default_val;
}

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  using enable_if_convertible_t = std::enable_if_t::value>;

template  using conjunction = std::is_same, detail::bool_pack>;
template  using disjunction = std::integral_constant, detail::bool_pack>::value>;

template  using is_one_of           = disjunction::value...>;
template  using enable_if_one_of_t  = std::enable_if_t::value, T>;
template  using enable_if_one_of_vt = std::enable_if_t::value, void>;

template  using enable_if_arithmetic_t        = std::enable_if_t::value, R>;
template  using enable_if_signed_integral_t   = std::enable_if_t::value && std::is_signed::value, R>;
template  using enable_if_unsigned_integral_t = std::enable_if_t::value && std::is_unsigned::value, R>;
template  using enable_if_floatp_t            = std::enable_if_t::value, R>;

template          auto static_if(std::true_type, T t, F)  { return t; }
template          auto static_if(std::false_type, T, F f) { return f; }
template  auto static_if(T t, F f)                { return static_if(std::integral_constant{}, t, f); }
template              auto static_if(T t)                     { return static_if(std::integral_constant{}, t, [](auto&&...){}); }

}