bounded.h

Go to the documentation of this file.

 
#pragma once
 
#include "./concepts.h"
 
#include <optional>
#include <type_traits>
 
namespace emlabcpp
{
 
template < typename T, T MinVal, T MaxVal >
class bounded
{
        static_assert( MinVal <= MaxVal, "MinVal must be less than or equal to MaxVal" );
        T val_;
 
        constexpr explicit bounded( T val )
          : val_( val )
        {
        }
 
public:
        static constexpr T    min_val            = MinVal;
        static constexpr T    max_val            = MaxVal;
        static constexpr T    interval_range     = static_cast< T >( 1 ) + max_val - min_val;
        static constexpr bool has_single_element = MinVal == MaxVal;
 
        template < typename U, U OtherMin, U OtherMax >
        requires(
            std::is_integral_v< U > && std::is_integral_v< T > && min_val <= OtherMin &&
            OtherMax <= max_val )
        constexpr bounded( bounded< U, OtherMin, OtherMax > other )
          : val_( static_cast< T >( *other ) )
        {
        }
 
        template < T Val >
        static constexpr bounded get()
        {
                static_assert( min_val <= Val && Val <= max_val, "Value out of bounds" );
                return bounded{ Val };
        }
 
        template < typename U >
        static std::optional< bounded< T, min_val, max_val > > make( U val )
        {
                if ( static_cast< T >( val ) < min_val )
                        return {};
                if ( static_cast< T >( val ) > max_val )
                        return {};
                return bounded{ static_cast< T >( val ) };
        }
 
        static bounded< T, min_val, max_val > min()
        {
                return bounded{ min_val };
        }
 
        static bounded< T, min_val, max_val > max()
        {
                return bounded{ max_val };
        }
 
        constexpr bounded()
          : val_( min_val )
        {
        }
 
        constexpr T operator*() const
        {
                return val_;
        }
 
        explicit operator T() const
        {
                return val_;
        }
 
        void rotate_right( T step )
        {
                val_ = min_val + ( interval_range + ( val_ + step - min_val ) % interval_range ) %
                                     interval_range;
        }
 
        void rotate_left( T step )
        {
                val_ = min_val + ( interval_range + ( val_ - step - min_val ) % interval_range ) %
                                     interval_range;
        }
 
        friend constexpr auto operator<=>( bounded const&, bounded const& ) = default;
 
        template < typename U >
        friend constexpr auto operator<=>( bounded const& b, U const& val )
        {
                return *b <=> val;
        }
 
        template < T FromOther, T ToOther >
        constexpr bounded< T, MinVal + FromOther, MaxVal + ToOther >
        operator+( bounded< T, FromOther, ToOther > const& other ) const
        {
                return bounded< T, MinVal + FromOther, MaxVal + ToOther >( val_ + *other );
        }
 
        template < typename U, U FromOther, U ToOther >
        friend class bounded;
};
 
template < std::size_t N >
constexpr auto bounded_constant = bounded< std::size_t, N, N >{};
 
namespace detail
{
        template < typename T, T MinVal, T MaxVal >
        constexpr bool bounded_derived_test( bounded< T, MinVal, MaxVal > const& )
        {
                return true;
        }
}  // namespace detail
 
template < typename T >
concept bounded_derived = requires( T val ) { detail::bounded_derived_test( val ); };
 
#ifdef EMLABCPP_USE_OSTREAM
template < typename T, T MinVal, T MaxVal >
std::ostream& operator<<( std::ostream& os, bounded< T, MinVal, MaxVal > const& b )
{
        return os << *b;
}
#endif
 
}  // namespace emlabcpp