msl::utilities Namespace Reference

Namespaces
	details

Classes
class	SafeInt
struct	SafeIntErrorPolicy_InvalidParameter
struct	SafeIntErrorPolicy_SafeIntException
class	SafeIntException

Enumerations
enum	SafeIntError { SafeIntNoError = 0, SafeIntArithmeticOverflow, SafeIntDivideByZero }

Functions
template<typename T , typename U >
bool	SafeCast (const T From, U &To) throw ()
template<typename T , typename U >
bool	SafeEquals (const T t, const U u) throw ()
template<typename T , typename U >
bool	SafeNotEquals (const T t, const U u) throw ()
template<typename T , typename U >
bool	SafeGreaterThan (const T t, const U u) throw ()
template<typename T , typename U >
bool	SafeGreaterThanEquals (const T t, const U u) throw ()
template<typename T , typename U >
bool	SafeLessThan (const T t, const U u) throw ()
template<typename T , typename U >
bool	SafeLessThanEquals (const T t, const U u) throw ()
template<typename T , typename U >
bool	SafeModulus (const T &t, const U &u, T &result) throw ()
template<typename T , typename U >
bool	SafeMultiply (T t, U u, T &result) throw ()
template<typename T , typename U >
bool	SafeDivide (T t, U u, T &result) throw ()
template<typename T , typename U >
bool	SafeAdd (T t, U u, T &result) throw ()
template<typename T , typename U >
bool	SafeSubtract (T t, U u, T &result) throw ()
template<typename T , typename U , typename E >
bool	operator< (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator< (SafeInt< U, E > lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator> (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator> (SafeInt< T, E > lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator>= (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator>= (SafeInt< T, E > lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator<= (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator<= (SafeInt< T, E > lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename E >
bool	operator== (bool lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator== (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator== (SafeInt< T, E > lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator!= (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename E >
bool	operator!= (bool lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
bool	operator!= (SafeInt< T, E > lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
SafeInt< T, E >	operator% (U lhs, SafeInt< T, E > rhs)
template<typename T , typename U , typename E >
SafeInt< T, E >	operator* (U lhs, SafeInt< T, E > rhs)
template<typename T , typename U , typename E >
SafeInt< T, E >	operator/ (U lhs, SafeInt< T, E > rhs)
template<typename T , typename U , typename E >
SafeInt< T, E >	operator+ (U lhs, SafeInt< T, E > rhs)
template<typename T , typename U , typename E >
SafeInt< T, E >	operator- (U lhs, SafeInt< T, E > rhs)
template<typename T , typename U , typename E >
T &	operator+= (T &lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T &	operator-= (T &lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T &	operator*= (T &lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T &	operator/= (T &lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T &	operator%= (T &lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T &	operator&= (T &lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
T &	operator^= (T &lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
T &	operator|= (T &lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
T &	operator<<= (T &lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
T &	operator>>= (T &lhs, SafeInt< U, E > rhs) throw ()
template<typename T , typename U , typename E >
T *&	operator+= (T *&lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator-= (T *&lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator*= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator/= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator%= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator&= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator^= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator|= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator<<= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
T *&	operator>>= (T *lhs, SafeInt< U, E > rhs)
template<typename T , typename U , typename E >
SafeInt< U, E >	operator<< (U lhs, SafeInt< T, E > bits) throw ()
template<typename T , typename U , typename E >
SafeInt< U, E >	operator>> (U lhs, SafeInt< T, E > bits) throw ()
template<typename T , typename U , typename E >
SafeInt< T, E >	operator& (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
SafeInt< T, E >	operator^ (U lhs, SafeInt< T, E > rhs) throw ()
template<typename T , typename U , typename E >
SafeInt< T, E >	operator| (U lhs, SafeInt< T, E > rhs) throw ()

Enumeration Type Documentation

enum msl::utilities::SafeIntError

Enumerator
SafeIntNoError
SafeIntArithmeticOverflow
SafeIntDivideByZero

{
    SafeIntNoError = 0,
    SafeIntArithmeticOverflow,
    SafeIntDivideByZero
};

Function Documentation

template<typename T , typename U , typename E >

bool msl::utilities::operator!=	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return !details::EqualityTest< T, U >::IsEquals( rhs, lhs );
}

template<typename T , typename E >

bool msl::utilities::operator!=	(	bool	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return ( (T)rhs == 0 ? false : true ) != lhs;
}

template<typename T , typename U , typename E >

bool msl::utilities::operator!=	(	SafeInt< T, E >	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    return !details::EqualityTest< T, U >::IsEquals( lhs, rhs );
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator%	(	U	lhs,
		SafeInt< T, E >	rhs
	)

{
    // Value of return depends on sign of lhs
    // This one may not be safe - bounds check in constructor
    // if lhs is negative and rhs is unsigned, this will throw an exception.

    // Fast-track the simple case
    // same size and same sign
#pragma warning(suppress:4127 6326)
    if( sizeof(T) == sizeof(U) && details::IntTraits< T >::isSigned == details::IntTraits< U >::isSigned )
    {
        if( rhs != 0 )
        {
            if( details::IntTraits< T >::isSigned && (T)rhs == -1 )
                return 0;

            return SafeInt< T, E >( (T)( lhs % (T)rhs ) );
        }

        E::SafeIntOnDivZero();
    }

    return SafeInt< T, E >( ( SafeInt< U, E >( lhs ) % (T)rhs ) );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator%=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)

{
    T ret( 0 );
    details::ModulusHelper< T, U, E >::Modulus( lhs, (U)rhs, ret );
    lhs = ret;
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator%=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator&	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return SafeInt< T, E >( details::BinaryAndHelper< T, U >::And( (T)rhs, lhs ) );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator&=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    lhs = details::BinaryAndHelper< T, U >::And( lhs, (U)rhs );
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator&=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator*	(	U	lhs,
		SafeInt< T, E >	rhs
	)

{
    T ret( 0 );
    details::MultiplicationHelper< T, U, E >::Multiply( (T)rhs, lhs, ret );
    return SafeInt< T, E >(ret);
}

template<typename T , typename U , typename E >

T& msl::utilities::operator*=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)

{
    T ret( 0 );
    details::MultiplicationHelper< T, U, E >::Multiply( lhs, (U)rhs, ret );
    lhs = ret;
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator*=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator+	(	U	lhs,
		SafeInt< T, E >	rhs
	)

{
    T ret( 0 );
    details::AdditionHelper< T, U, E >::Addition( (T)rhs, lhs, ret );
    return SafeInt< T, E >( ret );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator+=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)

{
    T ret( 0 );
    details::AdditionHelper< T, U, E >::Addition( lhs, (U)rhs, ret );
    lhs = ret;
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator+=	(	T *&	lhs,
		SafeInt< U, E >	rhs
	)

{
    // Cast the pointer to a number so we can do arithmetic
    SafeInt< uintptr_t, E > ptr_val = reinterpret_cast< uintptr_t >( lhs );
    // Check first that rhs is valid for the type of ptrdiff_t
    // and that multiplying by sizeof( T ) doesn't overflow a ptrdiff_t
    // Next, we need to add 2 SafeInts of different types, so unbox the ptr_diff
    // Finally, cast the number back to a pointer of the correct type
    lhs = reinterpret_cast< T* >( (uintptr_t)( ptr_val + (ptrdiff_t)( SafeInt< ptrdiff_t, E >( rhs ) * sizeof( T ) ) ) );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator-	(	U	lhs,
		SafeInt< T, E >	rhs
	)

{
    T ret( 0 );
    details::SubtractionHelper< U, T, E, details::SubtractionMethod2< U, T >::method >::Subtract( lhs, rhs.Ref(), ret );

    return SafeInt< T, E >( ret );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator-=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)

{
    T ret( 0 );
    details::SubtractionHelper< T, U, E >::Subtract( lhs, (U)rhs, ret );
    lhs = ret;
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator-=	(	T *&	lhs,
		SafeInt< U, E >	rhs
	)

{
    // Cast the pointer to a number so we can do arithmetic
    SafeInt< size_t, E > ptr_val = reinterpret_cast< uintptr_t >( lhs );
    // See above for comments
    lhs = reinterpret_cast< T* >( (uintptr_t)( ptr_val - (ptrdiff_t)( SafeInt< ptrdiff_t, E >( rhs ) * sizeof( T ) ) ) );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator/	(	U	lhs,
		SafeInt< T, E >	rhs
	)

{
#pragma warning(push)
#pragma warning(disable: 4127 4146 4307 4310 6326)
    // Corner case - has to be handled seperately
    if( details::DivisionMethod< U, T >::method ==  details::DivisionState_UnsignedSigned )
    {
        if( (T)rhs > 0 )
            return SafeInt< T, E >( lhs/(T)rhs );

        // Now rhs is either negative, or zero
        if( (T)rhs != 0 )
        {
            if( sizeof( U ) >= 4 && sizeof( T ) <= sizeof( U ) )
            {
                // Problem case - normal casting behavior changes meaning
                // flip rhs to positive
                // any operator casts now do the right thing
                U tmp;
                if( sizeof(T) == 4 )
                    tmp = lhs/(U)(unsigned __int32)( -(T)rhs );
                else
                    tmp = lhs/(U)( -(T)rhs );

                if( tmp <= details::IntTraits< T >::maxInt )
                    return SafeInt< T, E >( -( (T)tmp ) );

                // Corner case
                // Note - this warning happens because we're not using partial
                // template specialization in this case. For any real cases where
                // this block isn't optimized out, the warning won't be present.
                if( tmp == (U)details::IntTraits< T >::maxInt + 1 )
                    return SafeInt< T, E >( details::IntTraits< T >::minInt );

                E::SafeIntOnOverflow();
            }

            return SafeInt< T, E >(lhs/(T)rhs);
        }

        E::SafeIntOnDivZero();
    } // method == DivisionState_UnsignedSigned

    if( details::SafeIntCompare< T, U >::isBothSigned )
    {
        if( lhs == details::IntTraits< U >::minInt && (T)rhs == -1 )
        {
            // corner case of a corner case - lhs = min int, rhs = -1,
            // but rhs is the return type, so in essence, we can return -lhs
            // if rhs is a larger type than lhs
            if( sizeof( U ) < sizeof( T ) )
            {
                return SafeInt< T, E >( (T)( -(T)details::IntTraits< U >::minInt ) );
            }

            // If rhs is smaller or the same size int, then -minInt won't work
            E::SafeIntOnOverflow();
        }
    }

    // Otherwise normal logic works with addition of bounds check when casting from U->T
    U ret;
    details::DivisionHelper< U, T, E >::Divide( lhs, (T)rhs, ret );
    return SafeInt< T, E >( ret );
#pragma warning(pop)
}

template<typename T , typename U , typename E >

T& msl::utilities::operator/=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)

{
    T ret( 0 );
    details::DivisionHelper< T, U, E >::Divide( lhs, (U)rhs, ret );
    lhs = ret;
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator/=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

bool msl::utilities::operator<	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return details::GreaterThanTest< T, U >::GreaterThan( (T)rhs, lhs );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator<	(	SafeInt< U, E >	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return details::GreaterThanTest< T, U >::GreaterThan( (T)rhs, (U)lhs );
}

template<typename T , typename U , typename E >

SafeInt< U, E > msl::utilities::operator<<	(	U	lhs,
		SafeInt< T, E >	bits
	)
throw	(
	)

{
    _SAFEINT_SHIFT_ASSERT( !details::IntTraits< T >::isSigned || (T)bits >= 0 );
    _SAFEINT_SHIFT_ASSERT( (T)bits < (int)details::IntTraits< U >::bitCount );

    return SafeInt< U, E >( (U)( lhs << (T)bits ) );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator<<=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    lhs = (T)( SafeInt< T, E >( lhs ) << (U)rhs );
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator<<=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

bool msl::utilities::operator<=	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return !details::GreaterThanTest< U, T >::GreaterThan( lhs, (T)rhs );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator<=	(	SafeInt< T, E >	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    return !details::GreaterThanTest< T, U >::GreaterThan( (T)lhs, (U)rhs );
}

template<typename T , typename E >

bool msl::utilities::operator==	(	bool	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return lhs == ( (T)rhs == 0 ? false : true );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator==	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return details::EqualityTest< T, U >::IsEquals((T)rhs, lhs);
}

template<typename T , typename U , typename E >

bool msl::utilities::operator==	(	SafeInt< T, E >	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    return details::EqualityTest< T, U >::IsEquals( (T)lhs, (U)rhs );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator>	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return details::GreaterThanTest< U, T >::GreaterThan( lhs, (T)rhs );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator>	(	SafeInt< T, E >	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    return details::GreaterThanTest< T, U >::GreaterThan( (T)lhs, (U)rhs );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator>=	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return !details::GreaterThanTest< T, U >::GreaterThan( (T)rhs, lhs );
}

template<typename T , typename U , typename E >

bool msl::utilities::operator>=	(	SafeInt< T, E >	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    return !details::GreaterThanTest< U, T >::GreaterThan( (U)rhs, (T)lhs );
}

template<typename T , typename U , typename E >

SafeInt< U, E > msl::utilities::operator>>	(	U	lhs,
		SafeInt< T, E >	bits
	)
throw	(
	)

{
    _SAFEINT_SHIFT_ASSERT( !details::IntTraits< T >::isSigned || (T)bits >= 0 );
    _SAFEINT_SHIFT_ASSERT( (T)bits < (int)details::IntTraits< U >::bitCount );

    return SafeInt< U, E >( (U)( lhs >> (T)bits ) );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator>>=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    lhs = (T)( SafeInt< T, E >( lhs ) >> (U)rhs );
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator>>=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator^	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return SafeInt< T, E >(details::BinaryXorHelper< T, U >::Xor( (T)rhs, lhs ) );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator^=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    lhs = details::BinaryXorHelper< T, U >::Xor( lhs, (U)rhs );
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator^=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U , typename E >

SafeInt< T, E > msl::utilities::operator|	(	U	lhs,
		SafeInt< T, E >	rhs
	)
throw	(
	)

{
    return SafeInt< T, E >( details::BinaryOrHelper< T, U >::Or( (T)rhs, lhs ) );
}

template<typename T , typename U , typename E >

T& msl::utilities::operator|=	(	T &	lhs,
		SafeInt< U, E >	rhs
	)
throw	(
	)

{
    lhs = details::BinaryOrHelper< T, U >::Or( lhs, (U)rhs );
    return lhs;
}

template<typename T , typename U , typename E >

T*& msl::utilities::operator|=	(	T *	lhs,
		SafeInt< U, E >	rhs
	)

{
    static_assert( false, "SafeInt<T>: This operator explicitly not supported" );
    return lhs;
}

template<typename T , typename U >

bool msl::utilities::SafeAdd ( T  t, U  u, T &  result  ) throw ( )

inline

{
    return ( details::AdditionHelper< T, U,
        details::SafeIntErrorPolicy_NoThrow >::Addition( t, u, result ) == SafeIntNoError );
}

template<typename T , typename U >

bool msl::utilities::SafeCast ( const T  From, U &  To  ) throw ( )

inline

{
    return (details::SafeCastHelper< U, T,
        details::SafeIntErrorPolicy_NoThrow >::Cast( From, To ) == SafeIntNoError);
}

template<typename T , typename U >

bool msl::utilities::SafeDivide ( T  t, U  u, T &  result  ) throw ( )

inline

{
    return ( details::DivisionHelper< T, U,
        details::SafeIntErrorPolicy_NoThrow >::Divide( t, u, result ) == SafeIntNoError );
}

template<typename T , typename U >

bool msl::utilities::SafeEquals ( const T  t, const U  u  ) throw ( )

inline

{
    return details::EqualityTest< T, U >::IsEquals( t, u );
}

template<typename T , typename U >

bool msl::utilities::SafeGreaterThan ( const T  t, const U  u  ) throw ( )

inline

{
    return details::GreaterThanTest< T, U >::GreaterThan( t, u );
}

template<typename T , typename U >

bool msl::utilities::SafeGreaterThanEquals ( const T  t, const U  u  ) throw ( )

inline

{
    return !details::GreaterThanTest< U, T >::GreaterThan( u, t );
}

template<typename T , typename U >

bool msl::utilities::SafeLessThan ( const T  t, const U  u  ) throw ( )

inline

{
    return details::GreaterThanTest< U, T >::GreaterThan( u, t );
}

template<typename T , typename U >

bool msl::utilities::SafeLessThanEquals ( const T  t, const U  u  ) throw ( )

inline

{
    return !details::GreaterThanTest< T, U >::GreaterThan( t, u );
}

template<typename T , typename U >

bool msl::utilities::SafeModulus ( const T &  t, const U &  u, T &  result  ) throw ( )

inline

{
    return ( details::ModulusHelper< T, U, details::SafeIntErrorPolicy_NoThrow >::Modulus( t, u, result ) == SafeIntNoError );
}

template<typename T , typename U >

bool msl::utilities::SafeMultiply ( T  t, U  u, T &  result  ) throw ( )

inline

{
    return ( details::MultiplicationHelper< T, U,
        details::SafeIntErrorPolicy_NoThrow >::Multiply( t, u, result ) == SafeIntNoError );
}

template<typename T , typename U >

bool msl::utilities::SafeNotEquals ( const T  t, const U  u  ) throw ( )

inline

{
    return !details::EqualityTest< T, U >::IsEquals( t, u );
}

template<typename T , typename U >

bool msl::utilities::SafeSubtract ( T  t, U  u, T &  result  ) throw ( )

inline

{
    return ( details::SubtractionHelper< T, U,
        details::SafeIntErrorPolicy_NoThrow >::Subtract( t, u, result ) == SafeIntNoError );
}