SafeInt

Wrapper for any basic integral type N that uses the checked operations from safeOp and rejects attempts to directly assign values that cannot be proven to be within the range representable by N. (checkedint.to() can be used to safely assign values of incompatible types, with runtime bounds checking.)

SafeInt is designed to be as interchangeable with N as possible, without compromising safety. The DebugInt template allows a variable to use SafeInt in debug mode to find bugs, and N directly in release mode for greater speed and a smaller binary.

Outside of generic code that needs to work with both SafeInt!N and N, it is generally preferable to use SmartInt instead. It generates far fewer error messages: mostly it "just works".

policy controls the error signalling policy (see checkedint.flags).
bitOps may be set to No.bitOps if desired, to turn bitwise operations on this type into a compile-time error.

struct SafeInt(N, IntFlagPolicy _policy, Flag!"bitOps" bitOps = Yes.bitOps)
template SafeInt(N, IntFlagPolicy policy, Flag!"bitOps" bitOps = Yes.bitOps)
template SafeInt (
N
IntFlagPolicy policy
Flag!"bitOps" bitOps = Yes.bitOps
) if (
(
isIntegral!N &&
!isUnqual!N
) ||
isCheckedInt!N
) {
alias SafeInt = SafeInt!(BasicScalar!N, policy, bitOps);
}

Members

Aliases

SafeInt alias SafeInt = SafeInt!(BasicScalar!N, policy, bitOps): Undocumented in source.

Examples

// Mixing standard signed and unsigned types is dangerous...
int ba = -1;
uint bb = 0;
assert(ba > bb);

auto bc = ba + bb;
assert(is(typeof(bc) == uint));
assert(bc == 4294967295u);

// ...that's why SafeInt doesn't allow it.
import checkedint.throws : SafeInt, to; // use IntFlagPolicy.throws

SafeInt!int sa = -1;
SafeInt!uint sb = 0u;
static assert(!__traits(compiles, sa < sb));
static assert(!__traits(compiles, sa + sb));

// Instead, use checkedint.to() to safely convert to a common type...
auto sbi = to!(SafeInt!int)(sb);
assert(sa < sbi);
auto sc = sa + sbi;
assert(sc == -1);
// (...or just switch to SmartInt.)

// When IntFlagPolicy.throws is set, SafeInt operations that fail at runtime will throw a CheckedIntException.
import checkedint.throws : SafeInt;

SafeInt!uint sa = 1u;
SafeInt!uint sb = 0u;

bool overflow = false;
try
{
    SafeInt!uint sc = sb - sa;
    assert(false);
}
catch (CheckedIntException e)
{
    assert(e.intFlags == IntFlag.negOver);
    overflow = true;
}
assert(overflow);

bool div0 = false;
try
{
    // With standard integers, this would crash the program with an unrecoverable FPE...
    SafeInt!uint sc = sa / sb;
    assert(false);
}
catch (CheckedIntException e)
{
    // ...but with SafeInt, it just throws a normal Exception.
    assert(e.intFlags == IntFlag.div0);
    div0 = true;
}
assert(div0);

// When IntFlagPolicy.sticky is set, SafeInt operations that fail at runtime set one or more bits in IntFlags.local.
import checkedint.sticky : SafeInt;

SafeInt!uint sa = 1u;
SafeInt!uint sb = 0u;
SafeInt!uint sc;

sc = sb - sa;
assert(IntFlags.local == IntFlag.over);

// With standard integers, this would crash the program with an unrecoverable FPE...
sc = sa / sb;
// ...but with SmartInt, it just sets a bit in IntFlags.local.
assert(IntFlags.local & IntFlag.div0);

// Each flag will remain set until cleared:
assert(IntFlags.local.clear() == (IntFlag.over | IntFlag.div0));
assert(!IntFlags.local);

SafeInt

Members

Aliases

Examples

Meta

Source