safe_signed_range<MIN, MAX, PP, EP> and safe_unsigned

safe_signed_range<MIN, MAX, PP, EP> and safe_unsigned_range<MIN, MAX, PP, EP>

Description
Notation
Associated Types
Template Parameters
Model of
Valid Expressions
Example of use
Header

Description

This type holds a signed or unsigned integer in the closed range [MIN, MAX]. A safe_signed_range<MIN, MAX, PP, EP> or safe_unsigned_range<MIN, MAX, PP, EP> can be used anywhere an arithmetic type is permitted. Any expression which uses either of these types is guaranteed to return an arithmetically correct value or to trap in some way.

Notation

Symbol	Description
`MIN, MAX`	Minimum and maximum values that the range can represent.

Associated Types

`PP`	Promotion Policy. A type which specifies the result type of an expression using safe types.
`EP`	Exception Policy. A type containing members which are called when a correct result cannot be returned

Template Parameters

Parameter	Requirements	Description
`MIN`	must be a non-negative literal	The minimum non-negative integer value that this type may hold
`MAX`	must be a non-negative literal	The maximum non-negative integer value that this type may hold
	MIN <= MAX	must be a valid closed range
`PP`	PromotionPolicy<PP>	Default value is `boost::numeric::native`
`EP`	Exception Policy<EP>	Default value is `boost::numeric::default_exception_policy`

Model of

Integer

SafeNumeric

Valid Expressions

Implements all expressions and only those expressions defined by the SafeNumeric type requirements. Thus, the result type of such an expression will be another safe type. The actual type of the result of such an expression will depend upon the specific promotion policy template parameter.

Example of use

#include <type_traits>
#include <boost/safe_numerics/safe_integer.hpp>
#include <boost/safe_numerics/safe_integer_range.hpp>

#include <boost/safe_numerics/utility.hpp>

using namespace boost::safe_numerics;

void f(){
    safe_unsigned_range<7, 24> i;
    // since the range is included in [0,255], the underlying type of i 
    // will be an unsigned char.
    i = 0;  // throws out_of_range exception
    i = 9;  // ok
    i *= 9; // throws out_of_range exception
    i = -1; // throws out_of_range exception
    std::uint8_t j = 4;
    auto k = i + j;

    // if either or both types are safe types, the result is a safe type
    // determined by promotion policy.  In this instance
    // the range of i is [7, 24] and the range of j is [0,255].
    // so the type of k will be a safe type with a range of [7,279]
    static_assert(
        is_safe<decltype(k)>::value
        && std::numeric_limits<decltype(k)>::min() == 7
        && std::numeric_limits<decltype(k)>::max() == 279,
        "k is a safe range of [7,279]"
    );
}

int main(){}

Header

#include <boost/numeric/safe_numerics/safe_range.hpp>

Safe Numerics