Zero.h

// Copyright (c) 2014, Tom Ritchford <tom@swirly.com>
 
#pragma once
 
namespace beast {

 
struct Zero
{
    explicit Zero() = default;
};
 
namespace {
constexpr Zero kZero{};
}  // namespace

template <typename T>
auto
signum(T const& t)
{
    return t.signum();
}
 
namespace detail::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
callSignum(T const& t)
{
    return signum(t);
}
 
}  // namespace detail::zero_helper
 
// Handle operators where T is on the left side using signum.
 
template <typename T>
bool
operator==(T const& t, Zero)
{
    return detail::zero_helper::callSignum(t) == 0;
}
 
template <typename T>
bool
operator!=(T const& t, Zero)
{
    return detail::zero_helper::callSignum(t) != 0;
}
 
template <typename T>
bool
operator<(T const& t, Zero)
{
    return detail::zero_helper::callSignum(t) < 0;
}
 
template <typename T>
bool
operator>(T const& t, Zero)
{
    return detail::zero_helper::callSignum(t) > 0;
}
 
template <typename T>
bool
operator>=(T const& t, Zero)
{
    return detail::zero_helper::callSignum(t) >= 0;
}
 
template <typename T>
bool
operator<=(T const& t, Zero)
{
    return detail::zero_helper::callSignum(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 == kZero;
}
 
template <typename T>
bool
operator!=(Zero, T const& t)
{
    return t != kZero;
}
 
template <typename T>
bool
operator<(Zero, T const& t)
{
    return t > kZero;
}
 
template <typename T>
bool
operator>(Zero, T const& t)
{
    return t < kZero;
}
 
template <typename T>
bool
operator>=(Zero, T const& t)
{
    return t <= kZero;
}
 
template <typename T>
bool
operator<=(Zero, T const& t)
{
    return t >= kZero;
}
 
}  // namespace beast