%PDF-
%PDF-
Mini Shell
Mini Shell
#ifndef BOOST_LEAF_PRED_HPP_INCLUDED
#define BOOST_LEAF_PRED_HPP_INCLUDED
// Copyright (c) 2018-2020 Emil Dotchevski and Reverge Studios, Inc.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_LEAF_ENABLE_WARNINGS
# if defined(__clang__)
# pragma clang system_header
# elif (__GNUC__*100+__GNUC_MINOR__>301)
# pragma GCC system_header
# elif defined(_MSC_VER)
# pragma warning(push,1)
# endif
#endif
#include <boost/leaf/handle_errors.hpp>
#if __cplusplus >= 201703L
# define BOOST_LEAF_MATCH_ARGS(et,v1,v) auto v1, auto... v
#else
# define BOOST_LEAF_MATCH_ARGS(et,v1,v) typename leaf_detail::et::type v1, typename leaf_detail::et::type... v
#endif
#define BOOST_LEAF_ESC(...) __VA_ARGS__
namespace boost { namespace leaf {
namespace leaf_detail
{
#if __cplusplus >= 201703L
template <class MatchType, class T>
BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE bool cmp_value_pack( MatchType const & e, bool (*P)(T) noexcept ) noexcept
{
BOOST_LEAF_ASSERT(P != 0);
return P(e);
}
template <class MatchType, class T>
BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE bool cmp_value_pack( MatchType const & e, bool (*P)(T) )
{
BOOST_LEAF_ASSERT(P != 0);
return P(e);
}
#endif
template <class MatchType, class V>
BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE bool cmp_value_pack( MatchType const & e, V v )
{
return e == v;
}
template <class MatchType, class VCar, class... VCdr>
BOOST_LEAF_CONSTEXPR BOOST_LEAF_ALWAYS_INLINE bool cmp_value_pack( MatchType const & e, VCar car, VCdr ... cdr )
{
return cmp_value_pack(e, car) || cmp_value_pack(e, cdr...);
}
}
////////////////////////////////////////
template <class E, class Enum = E>
struct condition
{
static_assert(std::is_error_condition_enum<Enum>::value || std::is_error_code_enum<Enum>::value, "leaf::condition<E, Enum> requires Enum to be registered either with std::is_error_condition_enum or std::is_error_code_enum.");
};
template <class Enum>
struct condition<Enum, Enum>
{
static_assert(std::is_error_condition_enum<Enum>::value || std::is_error_code_enum<Enum>::value, "leaf::condition<Enum> requires Enum to be registered either with std::is_error_condition_enum or std::is_error_code_enum.");
};
#if __cplusplus >= 201703L
template <class ErrorCodeEnum>
BOOST_LEAF_CONSTEXPR inline bool category( std::error_code const & ec )
{
static_assert(std::is_error_code_enum<ErrorCodeEnum>::value, "leaf::category requires an error code enum");
return &ec.category() == &std::error_code(ErrorCodeEnum{}).category();
}
#endif
////////////////////////////////////////
namespace leaf_detail
{
template <class T>
struct match_enum_type
{
using type = T;
};
template <class Enum>
struct match_enum_type<condition<Enum, Enum>>
{
using type = Enum;
};
template <class E, class Enum>
struct match_enum_type<condition<E, Enum>>
{
static_assert(sizeof(Enum) == 0, "leaf::condition<E, Enum> should be used with leaf::match_value<>, not with leaf::match<>");
};
}
template <class E, BOOST_LEAF_MATCH_ARGS(match_enum_type<E>, V1, V)>
struct match
{
using error_type = E;
E matched;
template <class T>
BOOST_LEAF_CONSTEXPR static bool evaluate(T && x)
{
return leaf_detail::cmp_value_pack(std::forward<T>(x), V1, V...);
}
};
template <class Enum, BOOST_LEAF_MATCH_ARGS(BOOST_LEAF_ESC(match_enum_type<condition<Enum, Enum>>), V1, V)>
struct match<condition<Enum, Enum>, V1, V...>
{
using error_type = std::error_code;
std::error_code const & matched;
BOOST_LEAF_CONSTEXPR static bool evaluate(std::error_code const & e) noexcept
{
return leaf_detail::cmp_value_pack(e, V1, V...);
}
};
template <class E, BOOST_LEAF_MATCH_ARGS(match_enum_type<E>, V1, V)>
struct is_predicate<match<E, V1, V...>>: std::true_type
{
};
////////////////////////////////////////
namespace leaf_detail
{
template <class E>
struct match_value_enum_type
{
using type = typename std::remove_reference<decltype(std::declval<E>().value)>::type;
};
template <class E, class Enum>
struct match_value_enum_type<condition<E, Enum>>
{
using type = Enum;
};
template <class Enum>
struct match_value_enum_type<condition<Enum, Enum>>
{
static_assert(sizeof(Enum)==0, "leaf::condition<Enum> should be used with leaf::match<>, not with leaf::match_value<>");
};
}
template <class E, BOOST_LEAF_MATCH_ARGS(match_value_enum_type<E>, V1, V)>
struct match_value
{
using error_type = E;
E const & matched;
BOOST_LEAF_CONSTEXPR static bool evaluate(E const & e) noexcept
{
return leaf_detail::cmp_value_pack(e.value, V1, V...);
}
};
template <class E, class Enum, BOOST_LEAF_MATCH_ARGS(BOOST_LEAF_ESC(match_value_enum_type<condition<E, Enum>>), V1, V)>
struct match_value<condition<E, Enum>, V1, V...>
{
using error_type = E;
E const & matched;
BOOST_LEAF_CONSTEXPR static bool evaluate(E const & e)
{
return leaf_detail::cmp_value_pack(e.value, V1, V...);
}
};
template <class E, BOOST_LEAF_MATCH_ARGS(match_value_enum_type<E>, V1, V)>
struct is_predicate<match_value<E, V1, V...>>: std::true_type
{
};
////////////////////////////////////////
#if __cplusplus >= 201703L
template <auto, auto, auto...>
struct match_member;
template <class T, class E, T E::* P, auto V1, auto... V>
struct match_member<P, V1, V...>
{
using error_type = E;
E const & matched;
BOOST_LEAF_CONSTEXPR static bool evaluate(E const & e) noexcept
{
return leaf_detail::cmp_value_pack(e.*P, V1, V...);
}
};
template <auto P, auto V1, auto... V>
struct is_predicate<match_member<P, V1, V...>>: std::true_type
{
};
#endif
////////////////////////////////////////
template <class P>
struct if_not
{
using error_type = typename P::error_type;;
decltype(std::declval<P>().matched) matched;
template <class E>
BOOST_LEAF_CONSTEXPR static bool evaluate(E && e) noexcept
{
return !P::evaluate(std::forward<E>(e));
}
};
template <class P>
struct is_predicate<if_not<P>>: std::true_type
{
};
////////////////////////////////////////
#ifndef BOOST_LEAF_NO_EXCEPTIONS
namespace leaf_detail
{
template <class Ex>
BOOST_LEAF_CONSTEXPR inline bool check_exception_pack( std::exception const & ex, Ex const * ) noexcept
{
return dynamic_cast<Ex const *>(&ex)!=0;
}
template <class Ex, class... ExRest>
BOOST_LEAF_CONSTEXPR inline bool check_exception_pack( std::exception const & ex, Ex const *, ExRest const * ... ex_rest ) noexcept
{
return dynamic_cast<Ex const *>(&ex)!=0 || check_exception_pack(ex, ex_rest...);
}
BOOST_LEAF_CONSTEXPR inline bool check_exception_pack( std::exception const & ) noexcept
{
return true;
}
}
template <class... Ex>
struct catch_
{
using error_type = void;
std::exception const & matched;
BOOST_LEAF_CONSTEXPR static bool evaluate(std::exception const & ex) noexcept
{
return leaf_detail::check_exception_pack(ex, static_cast<Ex const *>(0)...);
}
};
template <class Ex>
struct catch_<Ex>
{
using error_type = void;
Ex const & matched;
BOOST_LEAF_CONSTEXPR static Ex const * evaluate(std::exception const & ex) noexcept
{
return dynamic_cast<Ex const *>(&ex);
}
explicit catch_( std::exception const & ex ):
matched(*dynamic_cast<Ex const *>(&ex))
{
}
};
template <class... Ex>
struct is_predicate<catch_<Ex...>>: std::true_type
{
};
#endif
} }
#endif
Zerion Mini Shell 1.0