Zero.h

// Copyright (c) 2014, Tom Ritchford <tom@swirly.com>
 
#pragma once
 
namespace beast {
 
struct Zero
{
    explicit Zero() = default;
};
 
namespace {
static constexpr Zero zero{};
}
 
template <typename T>
auto
signum(T const& t)
{
    return t.signum();
}
 
namespace detail {
namespace zero_helper {
 
// For argument dependent lookup to function properly, calls to signum must
// be made from a namespace that does not include overloads of the function..
template <class T>
auto
call_signum(T const& t)
{
    return signum(t);
}
 
}  // namespace zero_helper
}  // namespace detail
 
// Handle operators where T is on the left side using signum.
 
template <typename T>
bool
operator==(T const& t, Zero)
{
    return detail::zero_helper::call_signum(t) == 0;
}
 
template <typename T>
bool
operator!=(T const& t, Zero)
{
    return detail::zero_helper::call_signum(t) != 0;
}
 
template <typename T>
bool
operator<(T const& t, Zero)
{
    return detail::zero_helper::call_signum(t) < 0;
}
 
template <typename T>
bool
operator>(T const& t, Zero)
{
    return detail::zero_helper::call_signum(t) > 0;
}
 
template <typename T>
bool
operator>=(T const& t, Zero)
{
    return detail::zero_helper::call_signum(t) >= 0;
}
 
template <typename T>
bool
operator<=(T const& t, Zero)
{
    return detail::zero_helper::call_signum(t) <= 0;
}
 
// Handle operators where T is on the right side by
// reversing the operation, so that T is on the left side.
 
template <typename T>
bool
operator==(Zero, T const& t)
{
    return t == zero;
}
 
template <typename T>
bool
operator!=(Zero, T const& t)
{
    return t != zero;
}
 
template <typename T>
bool
operator<(Zero, T const& t)
{
    return t > zero;
}
 
template <typename T>
bool
operator>(Zero, T const& t)
{
    return t < zero;
}
 
template <typename T>
bool
operator>=(Zero, T const& t)
{
    return t <= zero;
}
 
template <typename T>
bool
operator<=(Zero, T const& t)
{
    return t >= zero;
}
 
}  // namespace beast