Danny Robson
2e54950b1a
generally we use this for identifiers, and allowing the user to express arbitrary values from default construction isn't a great idea.
131 lines
6.6 KiB
C++
131 lines
6.6 KiB
C++
/*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* Copyright 2015 Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
#ifndef __UTIL_STRONGDEF_HPP
|
|
#define __UTIL_STRONGDEF_HPP
|
|
|
|
#include <limits>
|
|
#include <type_traits>
|
|
|
|
namespace util {
|
|
/// A transparent wrapper around a (typically lightweight) type for the
|
|
/// purposes of overload disambiguation. It acts like a typesafe typedef.
|
|
template <typename T,typename Tag>
|
|
struct strongdef {
|
|
public:
|
|
using value_type = T;
|
|
using tag_type = Tag;
|
|
|
|
constexpr strongdef () = delete;
|
|
constexpr explicit strongdef (const T &_data): data (_data) { ; }
|
|
constexpr strongdef (const strongdef &rhs): data (rhs.data) { ; }
|
|
|
|
// explicitly disable assignment with unequal types or tags. this
|
|
// prevents the converion operator getting invoked and falsely
|
|
// allowing assignment with differing types or tags.
|
|
template <typename U, typename TagU>
|
|
std::enable_if_t<
|
|
!std::is_same<T,U>::value || !std::is_same<Tag,TagU>::value,
|
|
strongdef<T,Tag>&
|
|
>
|
|
operator= (const strongdef<U,TagU> &rhs) = delete;
|
|
|
|
template <typename U, typename TagU>
|
|
std::enable_if_t<
|
|
std::is_same<T,U>::value && std::is_same<Tag,TagU>::value,
|
|
strongdef<T,Tag>&
|
|
>
|
|
operator= (const strongdef<U,TagU> &rhs)
|
|
{ data = rhs.data; return *this; }
|
|
|
|
// simple value_type assignment.
|
|
strongdef& operator= (const T &rhs)&
|
|
{ data = rhs; return *this; }
|
|
|
|
// conversion operators must not be explicit or it defeats the point
|
|
// of this class (ease of use, transparency).
|
|
operator const T& (void) const& { return data; }
|
|
operator T& (void) & { return data; }
|
|
|
|
// explicitly disable equality with unequal types or tags. this
|
|
// prevents the conversion operator getting invoked and falsely
|
|
// allowing equality with different types or tags.
|
|
template <typename U, typename TagU>
|
|
std::enable_if_t<
|
|
!std::is_same<T,U>::value ||
|
|
!std::is_same<Tag,TagU>::value,
|
|
bool
|
|
>
|
|
operator== (const strongdef<U,TagU> &rhs) const = delete;
|
|
|
|
// provide a usable equality for equal types and tags
|
|
template <typename U, typename TagU>
|
|
constexpr
|
|
std::enable_if_t<
|
|
std::is_same<T,U>::value &&
|
|
std::is_same<Tag,TagU>::value,
|
|
bool
|
|
>
|
|
operator== (const strongdef<U,TagU> &rhs) const { return data == rhs.data; }
|
|
|
|
T data;
|
|
};
|
|
}
|
|
|
|
|
|
namespace std {
|
|
template <typename T, typename Tag>
|
|
struct numeric_limits<util::strongdef<T,Tag>> {
|
|
using value_type = typename util::strongdef<T,Tag>::value_type;
|
|
|
|
static constexpr bool is_specialized = numeric_limits<value_type>::is_specialized;
|
|
static constexpr bool is_signed = numeric_limits<value_type>::is_signed;
|
|
static constexpr bool is_integer = numeric_limits<value_type>::is_integer;
|
|
static constexpr bool is_exact = numeric_limits<value_type>::is_exact;
|
|
static constexpr bool has_infinity = numeric_limits<value_type>::has_infinity;
|
|
static constexpr bool has_quiet_NaN = numeric_limits<value_type>::has_quiet_NaN;
|
|
static constexpr bool has_signaling_NaN = numeric_limits<value_type>::has_signaling_NaN;
|
|
static constexpr bool has_denorm = numeric_limits<value_type>::has_denorm;
|
|
static constexpr bool has_denorm_loss = numeric_limits<value_type>::has_denorm_loss;
|
|
static constexpr std::float_round_style round_style = numeric_limits<value_type>::round_style;
|
|
static constexpr bool is_iec559 = numeric_limits<value_type>::is_iec559;
|
|
static constexpr bool is_bounded = numeric_limits<value_type>::is_bounded;
|
|
static constexpr bool is_modulo = numeric_limits<value_type>::is_modulo;
|
|
static constexpr int digits = numeric_limits<value_type>::digits;
|
|
static constexpr int digits10 = numeric_limits<value_type>::digits10;
|
|
static constexpr int max_digits10 = numeric_limits<value_type>::max_digits10;
|
|
static constexpr int radix = numeric_limits<value_type>::radix;
|
|
static constexpr int min_exponent = numeric_limits<value_type>::min_exponent;
|
|
static constexpr int min_exponent10 = numeric_limits<value_type>::min_exponent10;
|
|
static constexpr int max_exponent = numeric_limits<value_type>::max_exponent;
|
|
static constexpr int max_exponent10 = numeric_limits<value_type>::max_exponent10;
|
|
static constexpr bool traps = numeric_limits<value_type>::traps;
|
|
static constexpr bool tinyness_before = numeric_limits<value_type>::tinyness_before;
|
|
|
|
static constexpr value_type min (void) { return numeric_limits<value_type>::min (); }
|
|
static constexpr value_type lowest (void) { return numeric_limits<value_type>::lowest (); }
|
|
static constexpr value_type max (void) { return numeric_limits<value_type>::max (); }
|
|
static constexpr value_type epsilon (void) { return numeric_limits<value_type>::epsilon (); }
|
|
static constexpr value_type round_error (void) { return numeric_limits<value_type>::round_error (); }
|
|
static constexpr value_type infinity (void) { return numeric_limits<value_type>::infinity (); }
|
|
static constexpr value_type quiet_NaN (void) { return numeric_limits<value_type>::quiet_NaN (); }
|
|
static constexpr value_type signaling_NaN (void) { return numeric_limits<value_type>::signaling_NaN (); }
|
|
static constexpr value_type denorm_min (void) { return numeric_limits<value_type>::denorm_min (); }
|
|
};
|
|
}
|
|
|
|
#endif
|