|
|
#ifndef OPAQUE_NUMERIC_TYPEDEF_HPP
|
|
|
#define OPAQUE_NUMERIC_TYPEDEF_HPP
|
|
|
//
|
|
|
// Copyright (c) 2015, 2016
|
|
|
// Kyle Markley. All rights reserved.
|
|
|
//
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
// modification, are permitted provided that the following conditions are met:
|
|
|
//
|
|
|
// 1. Redistributions of source code must retain the above copyright notice,
|
|
|
// this list of conditions and the following disclaimer.
|
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
|
// and/or other materials provided with the distribution.
|
|
|
// 3. Neither the name of the author nor the names of any contributors may be
|
|
|
// used to endorse or promote products derived from this software without
|
|
|
// specific prior written permission.
|
|
|
//
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
//
|
|
|
#include "binop/binop_inherit.hpp"
|
|
|
#include "data.hpp"
|
|
|
#include <type_traits>
|
|
|
#include <utility>
|
|
|
|
|
|
namespace opaque {
|
|
|
|
|
|
/// \addtogroup typedefs
|
|
|
/// @{
|
|
|
|
|
|
///
|
|
|
/// Numeric opaque typedef base type
|
|
|
///
|
|
|
/// Same as numeric_typedef, but without providing operator@ in terms of
|
|
|
/// operator@= by default. (Deriving from this rather than numeric_typedef
|
|
|
/// can avoid the need to remove a provided operator@ via a template
|
|
|
/// specialization.)
|
|
|
///
|
|
|
/// This is a suitable base class when you want to control the interface of
|
|
|
/// your type, including its interoperability with itself and other types.
|
|
|
/// Delete operations that you do not want, and add operations that you do
|
|
|
/// want.
|
|
|
///
|
|
|
/// You may define the behavior of mixed-type operator@ in your subclass by
|
|
|
/// inheriting from the opaque::binop::opname classes and providing the type
|
|
|
/// details. The list of template arguments for these classes is:
|
|
|
/// -# return type
|
|
|
/// -# commutative (bool)
|
|
|
/// -# type of left operand
|
|
|
/// -# type of right operand
|
|
|
/// -# type to convert left operand to
|
|
|
/// -# type to convert right operand to
|
|
|
///
|
|
|
/// If you do not desire certain standard numeric operations, simply delete
|
|
|
/// them in your subclass. (Note that it is simpler to delete an unwanted
|
|
|
/// operation than to supply a missing one that is desired.)
|
|
|
///
|
|
|
template <typename U, typename O, typename S = unsigned>
|
|
|
struct numeric_typedef_base : data<U,O> {
|
|
|
private:
|
|
|
using base = opaque::data<U,O>;
|
|
|
public:
|
|
|
using typename base::underlying_type;
|
|
|
using typename base::opaque_type;
|
|
|
typedef S shift_type;
|
|
|
using base::value;
|
|
|
|
|
|
constexpr14 opaque_type& operator*=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value *= peer.value )) {
|
|
|
value *= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator/=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value /= peer.value )) {
|
|
|
value /= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator%=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value %= peer.value )) {
|
|
|
value %= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator+=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value += peer.value )) {
|
|
|
value += peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator-=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value -= peer.value )) {
|
|
|
value -= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator<<=(const shift_type& count) &
|
|
|
noexcept(noexcept( value <<= count )) {
|
|
|
value <<= count;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator>>=(const shift_type& count) &
|
|
|
noexcept(noexcept( value >>= count )) {
|
|
|
value >>= count;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator&=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value &= peer.value )) {
|
|
|
value &= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator^=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value ^= peer.value )) {
|
|
|
value ^= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator|=(const opaque_type& peer) &
|
|
|
noexcept(noexcept( value |= peer.value )) {
|
|
|
value |= peer.value;
|
|
|
return downcast(); }
|
|
|
|
|
|
|
|
|
constexpr14 opaque_type& operator++() &
|
|
|
noexcept(noexcept( ++value )) {
|
|
|
++value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type& operator--() &
|
|
|
noexcept(noexcept( --value )) {
|
|
|
--value;
|
|
|
return downcast(); }
|
|
|
|
|
|
constexpr14 opaque_type operator++(int) & noexcept(noexcept(
|
|
|
std::declval<numeric_typedef_base&>().operator++()) and
|
|
|
std::is_nothrow_constructible<opaque_type, underlying_type>::value) {
|
|
|
opaque_type r(value); operator++(); return r; }
|
|
|
|
|
|
constexpr14 opaque_type operator--(int) & noexcept(noexcept(
|
|
|
std::declval<numeric_typedef_base&>().operator++()) and
|
|
|
std::is_nothrow_constructible<opaque_type, underlying_type>::value) {
|
|
|
opaque_type r(value); operator--(); return r; }
|
|
|
|
|
|
|
|
|
constexpr opaque_type operator+() const &
|
|
|
noexcept(noexcept( opaque_type(+ value ) )) {
|
|
|
return opaque_type(+ value ); }
|
|
|
|
|
|
constexpr14 opaque_type operator+() &&
|
|
|
noexcept(noexcept( opaque_type(+opaque::move(value)) )) {
|
|
|
return opaque_type(+opaque::move(value)); }
|
|
|
|
|
|
constexpr opaque_type operator-() const &
|
|
|
noexcept(noexcept( opaque_type(- value ) )) {
|
|
|
return opaque_type(- value ); }
|
|
|
|
|
|
constexpr14 opaque_type operator-() &&
|
|
|
noexcept(noexcept( opaque_type(-opaque::move(value)) )) {
|
|
|
return opaque_type(-opaque::move(value)); }
|
|
|
|
|
|
constexpr opaque_type operator~() const &
|
|
|
noexcept(noexcept( opaque_type(~ value ) )) {
|
|
|
return opaque_type(~ value ); }
|
|
|
|
|
|
constexpr14 opaque_type operator~() &&
|
|
|
noexcept(noexcept( opaque_type(~opaque::move(value)) )) {
|
|
|
return opaque_type(~opaque::move(value)); }
|
|
|
|
|
|
constexpr bool operator!() const
|
|
|
noexcept(noexcept( !value )) {
|
|
|
return !value; }
|
|
|
|
|
|
constexpr bool operator==(const opaque_type& peer) const
|
|
|
noexcept(noexcept( value == peer.value )) {
|
|
|
return value == peer.value; }
|
|
|
constexpr bool operator!=(const opaque_type& peer) const
|
|
|
noexcept(noexcept( value != peer.value )) {
|
|
|
return value != peer.value; }
|
|
|
constexpr bool operator< (const opaque_type& peer) const
|
|
|
noexcept(noexcept( value < peer.value )) {
|
|
|
return value < peer.value; }
|
|
|
constexpr bool operator> (const opaque_type& peer) const
|
|
|
noexcept(noexcept( value > peer.value )) {
|
|
|
return value > peer.value; }
|
|
|
constexpr bool operator<=(const opaque_type& peer) const
|
|
|
noexcept(noexcept( value <= peer.value )) {
|
|
|
return value <= peer.value; }
|
|
|
constexpr bool operator>=(const opaque_type& peer) const
|
|
|
noexcept(noexcept( value >= peer.value )) {
|
|
|
return value >= peer.value; }
|
|
|
|
|
|
/// Check whether the underlying value is nonzero
|
|
|
explicit constexpr operator bool() const
|
|
|
noexcept(noexcept( static_cast<bool>(value) )) {
|
|
|
return static_cast<bool>(value); }
|
|
|
|
|
|
|
|
|
using base::base;
|
|
|
explicit numeric_typedef_base() = default;
|
|
|
numeric_typedef_base(const numeric_typedef_base& ) = default;
|
|
|
numeric_typedef_base( numeric_typedef_base&&) = default;
|
|
|
numeric_typedef_base& operator=(const numeric_typedef_base& ) & = default;
|
|
|
numeric_typedef_base& operator=( numeric_typedef_base&&) & = default;
|
|
|
protected:
|
|
|
~numeric_typedef_base() = default;
|
|
|
using base::downcast;
|
|
|
};
|
|
|
|
|
|
///
|
|
|
/// Numeric opaque typedef
|
|
|
///
|
|
|
/// This is a base class providing wrappers for numeric operations on a
|
|
|
/// user-supplied type, which may be user-defined or built-in. The purpose of
|
|
|
/// this type is to easily enable the creation of several rigorously separate
|
|
|
/// numeric types so that they cannot be accidentally mixed in expressions,
|
|
|
/// implicitly converted, and also to enable overloading.
|
|
|
///
|
|
|
/// For example, you could create separate types for coordinates in each of
|
|
|
/// several dimensions, and it would be a compile-time error to mix those types
|
|
|
/// in a single expression, even if the the same underlying type was used to
|
|
|
/// represent all of them.
|
|
|
///
|
|
|
/// Template arguments for numeric_typedef:
|
|
|
/// -# U : The underlying type holding the value
|
|
|
/// -# O : The opaque type, your subclass
|
|
|
/// -# S : The right-hand operand type for shift operations
|
|
|
///
|
|
|
template <typename U, typename O, typename S = unsigned>
|
|
|
struct numeric_typedef : numeric_typedef_base<U,O,S>
|
|
|
, binop::multipliable <O>
|
|
|
, binop::dividable <O>
|
|
|
, binop::modulable <O>
|
|
|
, binop::addable <O>
|
|
|
, binop::subtractable <O>
|
|
|
, binop::left_shiftable <O, false, O, S>
|
|
|
, binop::right_shiftable<O, false, O, S>
|
|
|
, binop::bitandable <O>
|
|
|
, binop::bitxorable <O>
|
|
|
, binop::bitorable <O>
|
|
|
{
|
|
|
using numeric_typedef_base<U,O,S>::numeric_typedef_base;
|
|
|
explicit numeric_typedef() = default;
|
|
|
numeric_typedef(const numeric_typedef& ) = default;
|
|
|
numeric_typedef( numeric_typedef&&) = default;
|
|
|
numeric_typedef& operator=(const numeric_typedef& ) & = default;
|
|
|
numeric_typedef& operator=( numeric_typedef&&) & = default;
|
|
|
protected:
|
|
|
~numeric_typedef() = default;
|
|
|
};
|
|
|
|
|
|
/// @}
|
|
|
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
