it_bus/integer.h

#ifndef _IT_BUS_INTEGER_H_
#define _IT_BUS_INTEGER_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#ifndef IT_MINIMISE_INCLUDES
#include <it_dsa/fixed_point.h>
#endif

#include <it_cal/types.h>
#include <it_bus/exception.h>
#include <it_bus/api_defines.h>
#include <it_bus/any_simple_type.h>

namespace IT_Reflect
{
    class Reflection;
    template <class T> class ValueRef;
}

namespace IT_Bus
{
    class IT_AFC_API Integer : public AnySimpleType
    {
      public:
        typedef IT_Reflect::ValueRef<IT_Bus::Integer> IT_ReflectionType;

        Integer(
        ) IT_THROW_DECL(());

        Integer(
            short value
        ) IT_THROW_DECL(());

        Integer(
            unsigned short value
        ) IT_THROW_DECL(());

        Integer(
            int value
        ) IT_THROW_DECL(());

        Integer(
            unsigned int value
        ) IT_THROW_DECL(());

        Integer(
            long value
        ) IT_THROW_DECL(());

        Integer(
            unsigned long value
        ) IT_THROW_DECL(());

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        Integer(
            IT_LongLong value
        ) IT_THROW_DECL(());

        Integer(
            IT_ULongLong value
        ) IT_THROW_DECL(());
#endif

        Integer(
            const char* value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer(
            const String& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer(
            const Decimal& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer(
            const Integer& copy
        ) IT_THROW_DECL(());

        Integer&
        operator=(
            const Integer& rhs
        ) IT_THROW_DECL(());

        Integer&
        operator+=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer&
        operator-=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer&
        operator*=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer&
        operator/=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer&
        operator%=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer&
        operator++(
        ) IT_THROW_DECL((IT_Bus::Exception));

        const Integer
        operator++(
            int
        ) IT_THROW_DECL((IT_Bus::Exception));

        Integer&
        operator--(
        ) IT_THROW_DECL((IT_Bus::Exception));

        const Integer
        operator--(
            int
        ) IT_THROW_DECL((IT_Bus::Exception));

        bool
        is_negative(
        ) const IT_THROW_DECL(());

        bool
        is_positive(
        ) const IT_THROW_DECL(());

        bool
        is_non_negative(
        ) const IT_THROW_DECL(());

        bool
        is_non_positive(
        ) const IT_THROW_DECL(());

        int
        compare(
            const Integer& other
        ) const IT_THROW_DECL(());

        const Decimal&
        get_value(
        ) const IT_THROW_DECL(());

        void
        set_value(
            const Decimal& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        String
        to_string(
        ) const IT_THROW_DECL(());

        static bool
        is_valid_integer(
            const Decimal& value
        ) IT_THROW_DECL(());

        // Implementation of methods from AnyType.
        //
        virtual AnyType&
        copy(
            const AnyType& copy
        );

        virtual AnyType::Kind
        get_kind() const;

        virtual const QName&
        get_type() const;

        virtual IT_Reflect::Reflection*
        get_reflection(
        ) IT_THROW_DECL((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection(
        ) const IT_THROW_DECL((IT_Reflect::ReflectException));

        // Implementation of methods from AnySimpleType.
        //
        virtual void
        write_value(
            AnySimpleTypeWriter& writer
        ) const IT_THROW_DECL((IT_Bus::SerializationException));

        virtual void
        read_value(
            AnySimpleTypeReader& reader
        ) IT_THROW_DECL((IT_Bus::DeserializationException));

        // Used by SchemaTypeTraits.
        //
        static const QName&
        get_static_type();

      protected:
        virtual void
        validate(
            const Decimal& value
        ) const IT_THROW_DECL((IT_Bus::Exception));

        static Decimal
        from_string(
            const char* value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        static Decimal
        from_signed(
            IT_LongLong value
        ) IT_THROW_DECL(());

        static Decimal
        from_unsigned(
            IT_ULongLong value
        ) IT_THROW_DECL(());
        
        static void
        validate_integer(
            const Decimal& value
        ) IT_THROW_DECL((IT_Bus::Exception));

        Decimal m_value;
    };

    class IT_AFC_API NonPositiveInteger : public Integer
    {
      public:
        typedef IT_Reflect::ValueRef<IT_Bus::NonPositiveInteger>
        IT_ReflectionType;

        NonPositiveInteger(
        ) IT_THROW_DECL(());

        NonPositiveInteger(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            unsigned short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            unsigned int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            unsigned long value
        ) IT_THROW_DECL((IT_Bus::Exception));

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        NonPositiveInteger(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            IT_ULongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));
#endif

        NonPositiveInteger(
            const char* value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            const String& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            const Decimal& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            const Integer& copy
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger(
            const NonPositiveInteger& copy
        ) IT_THROW_DECL(());

        NonPositiveInteger&
        operator=(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            unsigned short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            unsigned int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            unsigned long value
        ) IT_THROW_DECL((IT_Bus::Exception));

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        NonPositiveInteger&
        operator=(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            IT_ULongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));
#endif

        NonPositiveInteger&
        operator=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonPositiveInteger&
        operator=(
            const NonPositiveInteger& rhs
        ) IT_THROW_DECL(());

        static bool
        is_valid_non_positive_integer(
            const Decimal& value
        ) IT_THROW_DECL(());

        // Implementation of methods from AnyType.
        //
        virtual AnyType&
        copy(
            const AnyType& copy
        );

        virtual const QName&
        get_type() const;

        virtual IT_Reflect::Reflection*
        get_reflection(
        ) IT_THROW_DECL((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection(
        ) const IT_THROW_DECL((IT_Reflect::ReflectException));

        // Used by SchemaTypeTraits.
        //
        static const QName&
        get_static_type();

      protected:
        virtual void
        validate(
            const Decimal& value
        ) const IT_THROW_DECL((IT_Bus::Exception));

        static void
        validate_non_positive_integer(
            const Decimal& value
        ) IT_THROW_DECL((IT_Bus::Exception));
    };

    class IT_AFC_API NegativeInteger : public NonPositiveInteger
    {
      public:
        typedef IT_Reflect::ValueRef<IT_Bus::NegativeInteger>
        IT_ReflectionType;

        NegativeInteger(
        ) IT_THROW_DECL(());

        NegativeInteger(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        NegativeInteger(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));
#endif

        NegativeInteger(
            const char* value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger(
            const String& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger(
            const Decimal& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger(
            const Integer& copy
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger(
            const NegativeInteger& copy
        ) IT_THROW_DECL(());

        NegativeInteger&
        operator=(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger&
        operator=(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger&
        operator=(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        NegativeInteger&
        operator=(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));
#endif

        NegativeInteger&
        operator=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        NegativeInteger&
        operator=(
            const NegativeInteger& rhs
        ) IT_THROW_DECL(());

        static bool
        is_valid_negative_integer(
            const Decimal& value
        ) IT_THROW_DECL(());

        // Implementation of methods from AnyType.
        //
        virtual AnyType&
        copy(
            const AnyType& copy
        );

        virtual const QName&
        get_type() const;

        virtual IT_Reflect::Reflection*
        get_reflection(
        ) IT_THROW_DECL((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection(
        ) const IT_THROW_DECL((IT_Reflect::ReflectException));

        // Used by SchemaTypeTraits.
        //
        static const QName&
        get_static_type();

      protected:
        virtual void
        validate(
            const Decimal& value
        ) const IT_THROW_DECL((IT_Bus::Exception));

        static void
        validate_negative_integer(
            const Decimal& value
        ) IT_THROW_DECL((IT_Bus::Exception));
    };

    class IT_AFC_API NonNegativeInteger : public Integer
    {
      public:
        typedef IT_Reflect::ValueRef<IT_Bus::NonNegativeInteger>
        IT_ReflectionType;

        NonNegativeInteger(
        ) IT_THROW_DECL(());

        NonNegativeInteger(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            unsigned short value
        ) IT_THROW_DECL(());

        NonNegativeInteger(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            unsigned int value
        ) IT_THROW_DECL(());

        NonNegativeInteger(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            unsigned long value
        ) IT_THROW_DECL(());

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        NonNegativeInteger(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            IT_ULongLong value
        ) IT_THROW_DECL(());
#endif

        NonNegativeInteger(
            const char* value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            const String& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            const Decimal& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            const Integer& copy
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger(
            const NonNegativeInteger& copy
        ) IT_THROW_DECL(());

        NonNegativeInteger&
        operator=(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger&
        operator=(
            unsigned short value
        ) IT_THROW_DECL(());

        NonNegativeInteger&
        operator=(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger&
        operator=(
            unsigned int value
        ) IT_THROW_DECL(());

        NonNegativeInteger&
        operator=(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger&
        operator=(
            unsigned long value
        ) IT_THROW_DECL(());

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        NonNegativeInteger&
        operator=(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger&
        operator=(
            IT_ULongLong value
        ) IT_THROW_DECL(());
#endif

        NonNegativeInteger&
        operator=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        NonNegativeInteger&
        operator=(
            const NonNegativeInteger& rhs
        ) IT_THROW_DECL(());

        static bool
        is_valid_non_negative_integer(
            const Decimal& value
        ) IT_THROW_DECL(());

        // Implementation of methods from AnyType.
        //
        virtual AnyType&
        copy(
            const AnyType& copy
        );

        virtual const QName&
        get_type() const;

        virtual IT_Reflect::Reflection*
        get_reflection(
        ) IT_THROW_DECL((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection(
        ) const IT_THROW_DECL((IT_Reflect::ReflectException));

        // Used by SchemaTypeTraits.
        //
        static const QName&
        get_static_type();

      protected:
        virtual void
        validate(
            const Decimal& value
        ) const IT_THROW_DECL((IT_Bus::Exception));

        static void
        validate_non_negative_integer(
            const Decimal& value
        ) IT_THROW_DECL((IT_Bus::Exception));
    };

    class IT_AFC_API PositiveInteger : public NonNegativeInteger
    {
      public:
        typedef IT_Reflect::ValueRef<IT_Bus::PositiveInteger>
        IT_ReflectionType;

        PositiveInteger(
        ) IT_THROW_DECL(());

        PositiveInteger(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            unsigned short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            unsigned int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            unsigned long value
        ) IT_THROW_DECL((IT_Bus::Exception));

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        PositiveInteger(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            IT_ULongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));
#endif

        PositiveInteger(
            const char* value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            const String& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            const Decimal& value,
            bool truncate = false
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            const Integer& copy
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger(
            const PositiveInteger& copy
        ) IT_THROW_DECL(());

        PositiveInteger&
        operator=(
            short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            unsigned short value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            unsigned int value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            long value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            unsigned long value
        ) IT_THROW_DECL((IT_Bus::Exception));

#if !IT_LONG_LONG_IS_SAME_AS_LONG

        PositiveInteger&
        operator=(
            IT_LongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            IT_ULongLong value
        ) IT_THROW_DECL((IT_Bus::Exception));
#endif

        PositiveInteger&
        operator=(
            const Integer& rhs
        ) IT_THROW_DECL((IT_Bus::Exception));

        PositiveInteger&
        operator=(
            const PositiveInteger& rhs
        ) IT_THROW_DECL(());

        static bool
        is_valid_positive_integer(
            const Decimal& value
        ) IT_THROW_DECL(());

        // Implementation of methods from AnyType.
        //
        virtual AnyType&
        copy(
            const AnyType& copy
        );

        virtual const QName&
        get_type() const;

        virtual IT_Reflect::Reflection*
        get_reflection(
        ) IT_THROW_DECL((IT_Reflect::ReflectException));
        
        virtual const IT_Reflect::Reflection*
        get_reflection(
        ) const IT_THROW_DECL((IT_Reflect::ReflectException));

        // Used by SchemaTypeTraits.
        //
        static const QName&
        get_static_type();

      protected:
        virtual void
        validate(
            const Decimal& value
        ) const IT_THROW_DECL((IT_Bus::Exception));

        static void
        validate_positive_integer(
            const Decimal& value
        ) IT_THROW_DECL((IT_Bus::Exception));
    };

    extern IT_AFC_API bool
    operator==(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API bool
    operator!=(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API bool
    operator<(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API bool
    operator>(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API bool
    operator>=(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API bool
    operator<=(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API Integer
    operator+(
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API Integer
    operator-(
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API bool
    operator!(
        const Integer& rhs
    ) IT_THROW_DECL(());

    extern IT_AFC_API Integer
    operator+(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL((IT_Bus::Exception));

    extern IT_AFC_API Integer
    operator-(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL((IT_Bus::Exception));

    extern IT_AFC_API Integer
    operator*(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL((IT_Bus::Exception));

    extern IT_AFC_API Integer
    operator/(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL((IT_Bus::Exception));

    extern IT_AFC_API Integer
    operator%(
        const Integer& lhs,
        const Integer& rhs
    ) IT_THROW_DECL((IT_Bus::Exception));

}


#endif /*_IT_BUS_INTEGER_H_*/

---