IntTypes.hpp

Go to the documentation of this file.

// The Reactive C++ Toolbox.
// Copyright (C) 2013-2019 Swirly Cloud Limited
// Copyright (C) 2022 Reactive Markets Limited
//
// 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.
 
#ifndef TOOLBOX_UTIL_INTTYPES_HPP
#define TOOLBOX_UTIL_INTTYPES_HPP
 
#include <toolbox/util/TypeTraits.hpp>
 
#include <boost/functional/hash.hpp>
 
namespace toolbox {
inline namespace util {
 
template <typename ValueT>
struct IntPolicy {
    using ValueType = ValueT;
    static constexpr ValueT min() noexcept { return std::numeric_limits<ValueT>::min(); }
    static constexpr ValueT max() noexcept { return std::numeric_limits<ValueT>::max(); }
};
using Int16Policy = IntPolicy<std::int16_t>;
using Int32Policy = IntPolicy<std::int32_t>;
using Int64Policy = IntPolicy<std::int64_t>;
 
template <typename PolicyT>
struct TOOLBOX_PACKED IntWrapper {
    using ValueType = typename PolicyT::ValueType;
 
    template <typename RhsT>
        requires std::convertible_to<RhsT, ValueType>
    constexpr explicit IntWrapper(RhsT rhs) noexcept
    : value_{static_cast<ValueType>(rhs)}
    {
    }
 
    constexpr IntWrapper() noexcept = default;
    ~IntWrapper() = default;
 
    // Copy.
    constexpr IntWrapper(const IntWrapper&) noexcept = default;
    constexpr IntWrapper& operator=(const IntWrapper&) noexcept = default;
 
    // Move.
    constexpr IntWrapper(IntWrapper&&) noexcept = default;
    constexpr IntWrapper& operator=(IntWrapper&&) noexcept = default;
 
    constexpr ValueType count() const noexcept { return value_; }
 
    static constexpr IntWrapper min() noexcept { return PolicyT::min(); }
    static constexpr IntWrapper max() noexcept { return PolicyT::max(); }
    static constexpr IntWrapper zero() noexcept { return IntWrapper{0}; }
 
    // Assignment.
 
    constexpr IntWrapper& operator+=(IntWrapper rhs) noexcept
    {
        value_ += rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator-=(IntWrapper rhs) noexcept
    {
        value_ -= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator*=(IntWrapper rhs) noexcept
    {
        value_ *= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator/=(IntWrapper rhs) noexcept
    {
        value_ /= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator%=(IntWrapper rhs) noexcept
    {
        value_ %= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator&=(IntWrapper rhs) noexcept
    {
        value_ &= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator|=(IntWrapper rhs) noexcept
    {
        value_ |= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator^=(IntWrapper rhs) noexcept
    {
        value_ ^= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator<<=(IntWrapper rhs) noexcept
    {
        value_ <<= rhs.value_;
        return *this;
    }
 
    constexpr IntWrapper& operator>>=(IntWrapper rhs) noexcept
    {
        value_ >>= rhs.value_;
        return *this;
    }
 
    // Increment/Decrement.
 
    constexpr IntWrapper& operator++() noexcept
    {
        ++value_;
        return *this;
    }
 
    constexpr IntWrapper& operator--() noexcept
    {
        --value_;
        return *this;
    }
 
    constexpr IntWrapper operator++(int) noexcept { return IntWrapper{value_++}; }
 
    constexpr IntWrapper operator--(int) noexcept { return IntWrapper{value_--}; }
 
    // Arithmetic.
 
    constexpr IntWrapper operator+() const noexcept { return IntWrapper{+value_}; }
 
    constexpr IntWrapper operator-() const noexcept { return IntWrapper{-value_}; }
 
    friend constexpr IntWrapper operator+(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ + rhs.value_};
    }
 
    friend constexpr IntWrapper operator-(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ - rhs.value_};
    }
 
    friend constexpr IntWrapper operator*(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ * rhs.value_};
    }
 
    friend constexpr IntWrapper operator/(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ / rhs.value_};
    }
 
    friend constexpr IntWrapper operator%(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ % rhs.value_};
    }
 
    // Bitwise.
 
    constexpr IntWrapper operator~() const noexcept { return IntWrapper{~value_}; }
 
    friend constexpr IntWrapper operator&(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ & rhs.value_};
    }
 
    friend constexpr IntWrapper operator|(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ | rhs.value_};
    }
 
    friend constexpr IntWrapper operator^(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ ^ rhs.value_};
    }
 
    friend constexpr IntWrapper operator<<(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ << rhs.value_};
    }
 
    friend constexpr IntWrapper operator>>(IntWrapper lhs, IntWrapper rhs) noexcept
    {
        return IntWrapper{lhs.value_ >> rhs.value_};
    }
 
    // Comparison.
    friend constexpr auto operator<=>(const IntWrapper&, const IntWrapper&) noexcept = default;
    friend constexpr bool operator==(const IntWrapper&, const IntWrapper&) noexcept = default;
 
    // Stream.
 
    friend constexpr std::ostream& operator<<(std::ostream& os, IntWrapper rhs)
    {
        return os << rhs.value_;
    }
 
  private:
    ValueType value_;
};
 
static_assert(IntWrapper<Int32Policy>{1} == IntWrapper<Int32Policy>{1});
static_assert(IntWrapper<Int32Policy>{1} != IntWrapper<Int32Policy>{2});
static_assert(std::is_standard_layout_v<IntWrapper<Int32Policy>>
              && std::is_trivial_v<IntWrapper<Int32Policy>>);
static_assert(sizeof(IntWrapper<Int16Policy>) == 2, "must be specific size");
static_assert(sizeof(IntWrapper<Int32Policy>) == 4, "must be specific size");
static_assert(sizeof(IntWrapper<Int64Policy>) == 8, "must be specific size");
 
template <typename ValueT>
concept IsIntWrapper = is_instantiation_of<ValueT, IntWrapper>::value;
 
template <typename PolicyT>
std::size_t hash_value(IntWrapper<PolicyT> wrapper)
{
    boost::hash<typename PolicyT::ValueType> hasher;
    return hasher(wrapper.count());
}
 
template <typename ValueT>
    requires IsIntWrapper<ValueT>
struct TypeTraits<ValueT> {
    static constexpr auto from_string(std::string_view sv) noexcept
    {
        using UnderlyingTraits = TypeTraits<typename ValueT::ValueType>;
        return ValueT{UnderlyingTraits::from_string(sv)};
    }
};
 
struct Id16Policy : Int16Policy {};
struct Id32Policy : Int32Policy {};
struct Id64Policy : Int64Policy {};
 
using Id16 = IntWrapper<Id16Policy>;
 
constexpr Id16 operator""_id16(unsigned long long val) noexcept
{
    return Id16{val};
}
 
using Id32 = IntWrapper<Id32Policy>;
 
constexpr Id32 operator""_id32(unsigned long long val) noexcept
{
    return Id32{val};
}
 
using Id64 = IntWrapper<Id64Policy>;
 
constexpr Id64 operator""_id64(unsigned long long val) noexcept
{
    return Id64{val};
}
 
} // namespace util
} // namespace toolbox
 
namespace std {
template <typename PolicyT>
struct hash<toolbox::IntWrapper<PolicyT>> {
    inline std::size_t operator()(toolbox::IntWrapper<PolicyT> wrapper) const
    {
        return wrapper.count();
    }
};
} // namespace std
 
#endif // TOOLBOX_UTIL_INTTYPES_HPP