it_bus/nillable_types.h

#ifndef _IT_BUS_NILLABLE_TYPES_H_
#define _IT_BUS_NILLABLE_TYPES_H_

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

#include <it_bus/types.h>
#include <it_bus/ext_types.h>
#include <it_bus/integer.h>
#include <it_bus/binary_type.h>
#include <it_bus/binary_nillable_type.h>
#include <it_bus/nillable_value_base.h>
#include <it_bus/any_holder.h>
#include <it_schema_model/w3c_constants.h>

namespace IT_Bus
{

    class IT_AFC_API AnyHolderNillable :
        public NillableValueBase<IT_Bus::AnyHolder>
    {
      public:
        AnyHolderNillable();

        AnyHolderNillable(
            const AnyHolder& value
        );

        virtual
        ~AnyHolderNillable();

        const QName&
        get_type() const;

        AnyHolderNillable&
        operator=(
            const AnyHolderNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        AnyHolderNillable&
        operator=(
            const IT_Bus::AnyHolder & rhs
        );

        AnyHolderNillable&
        operator=(
            const IT_Bus::AnyHolder * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));

        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));
    };

    class IT_AFC_API BooleanNillable :
        public NillableValueBase<IT_Bus::Boolean>
    {
      public:
        BooleanNillable();

        BooleanNillable(
            const Boolean& value
        );

        virtual
        ~BooleanNillable();

        const QName&
        get_type() const;

        BooleanNillable&
        operator=(
            const BooleanNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        BooleanNillable&
        operator=(
            const IT_Bus::Boolean & rhs
        );

        BooleanNillable&
        operator=(
            const IT_Bus::Boolean * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API LongNillable :
        public NillableValueBase<IT_Bus::Long>
    {
      public:
        LongNillable();

        LongNillable(
            const Long& value
        );

        virtual
        ~LongNillable();

        const QName&
        get_type() const;

        LongNillable&
        operator=(
            const LongNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        LongNillable&
        operator=(
            const IT_Bus::Long & rhs
        );

        LongNillable&
        operator=(
            const IT_Bus::Long * rhs
        );


        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API ULongNillable :
        public NillableValueBase<IT_Bus::ULong>
    {
      public:
        ULongNillable();

        ULongNillable(
            const ULong& value
        );

        virtual
        ~ULongNillable();

        const QName&
        get_type() const;

        ULongNillable&
        operator=(
            const ULongNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        ULongNillable&
        operator=(
            const IT_Bus::ULong & rhs
        );

        ULongNillable&
        operator=(
            const IT_Bus::ULong * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API UIntNillable :
        public NillableValueBase<IT_Bus::UInt>
    {
      public:
        UIntNillable();

        UIntNillable(
            const UInt& value
        );

        virtual
        ~UIntNillable();

        const QName&
        get_type() const;

        UIntNillable&
        operator=(
            const UIntNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        UIntNillable&
        operator=(
            const IT_Bus::UInt & rhs
        );

        UIntNillable&
        operator=(
            const IT_Bus::UInt * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API IntNillable :
        public NillableValueBase<IT_Bus::Int>
    {
      public:
        IntNillable();

        IntNillable(
            const Int& value
        );

        virtual
        ~IntNillable();

        const QName&
        get_type() const;

        IntNillable&
        operator=(
            const IntNillable & rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        IntNillable&
        operator=(
            const IT_Bus::Int & rhs
        );

        IntNillable&
        operator=(
            const IT_Bus::Int * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API ShortNillable : public NillableValueBase<IT_Bus::Short>
    {
      public:
        ShortNillable();

        ShortNillable(
            const Short& value
        );

        virtual
        ~ShortNillable();

        const QName&
        get_type() const;

        ShortNillable&
        operator=(
            const ShortNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        ShortNillable&
        operator=(
            const IT_Bus::Short & rhs
        );

        ShortNillable&
        operator=(
            const IT_Bus::Short * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API UShortNillable :
        public NillableValueBase<IT_Bus::UShort>
    {
      public:
        UShortNillable();

        UShortNillable(
            const UShort& value
        );

        virtual
        ~UShortNillable();

        const QName&
        get_type() const ;

        UShortNillable&
        operator=(
            const UShortNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        UShortNillable&
        operator=(
            const IT_Bus::UShort & rhs
        );

        UShortNillable&
        operator=(
            const IT_Bus::UShort * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API StringNillable :
        public NillableValueBase<IT_Bus::String>
    {
      public:
        StringNillable();

        StringNillable(
            const String& value
        );

        virtual
        ~StringNillable();

        const QName&
        get_type() const;

        StringNillable&
        operator=(
            const StringNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        StringNillable&
        operator=(
            const IT_Bus::String & rhs
        );

        StringNillable&
        operator=(
            const IT_Bus::String * rhs
        );


        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API ByteNillable :
        public NillableValueBase<IT_Bus::Byte>
    {
      public:
        ByteNillable();

        ByteNillable(
            const Byte& value
        );

        virtual
        ~ByteNillable();

        const QName&
        get_type() const;

        ByteNillable&
        operator=(
            const ByteNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        ByteNillable&
        operator=(
            const IT_Bus::Byte & rhs
        );

        ByteNillable&
        operator=(
            const IT_Bus::Byte * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API UByteNillable :
        public NillableValueBase<IT_Bus::UByte>
    {
      public:
        UByteNillable();

        UByteNillable(
            const UByte& value
        );

        virtual
        ~UByteNillable();

        const QName&
        get_type() const;

        UByteNillable&
        operator=(
            const UByteNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        UByteNillable&
        operator=(
            const IT_Bus::UByte & rhs
        );

        UByteNillable&
        operator=(
            const IT_Bus::UByte * rhs
        );


        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API FloatNillable :
        public NillableValueBase<IT_Bus::Float>
    {
      public:
        FloatNillable();

        FloatNillable(
            const Float& value
        );

        virtual
        ~FloatNillable();

        const QName&
        get_type() const;

        FloatNillable&
        operator=(
            const FloatNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        FloatNillable&
        operator=(
            const IT_Bus::Float & rhs
        );

        FloatNillable&
        operator=(
            const IT_Bus::Float * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API DoubleNillable :
        public NillableValueBase<IT_Bus::Double>
    {
      public:
        DoubleNillable();

        DoubleNillable(
            const Double& value
        );

        virtual
        ~DoubleNillable();

        const QName&
        get_type() const;

        DoubleNillable&
        operator=(
            const DoubleNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        DoubleNillable&
        operator=(
            const IT_Bus::Double & rhs
        );

        DoubleNillable&
        operator=(
            const IT_Bus::Double * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API DecimalNillable :
        public NillableValueBase<IT_Bus::Decimal>
    {
      public:
        DecimalNillable();

        DecimalNillable(
            const Decimal& value
        );

        virtual
        ~DecimalNillable();

        const QName&
        get_type() const;

        DecimalNillable&
        operator=(
            const DecimalNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        DecimalNillable&
        operator=(
            const IT_Bus::Decimal & rhs
        );

        DecimalNillable&
        operator=(
            const IT_Bus::Decimal * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API IntegerNillable :
        public NillableValueBase<IT_Bus::Integer>
    {
      public:
        IntegerNillable();

        IntegerNillable(
            const Integer& value
        );

        virtual
        ~IntegerNillable();

        const QName&
        get_type() const;

        IntegerNillable&
        operator=(
            const IntegerNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        IntegerNillable&
        operator=(
            const IT_Bus::Integer & rhs
        );

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

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API PositiveIntegerNillable :
        public NillableValueBase<IT_Bus::PositiveInteger>
    {
      public:
        PositiveIntegerNillable();

        PositiveIntegerNillable(
            const PositiveInteger& value
        );

        virtual
        ~PositiveIntegerNillable();

        const QName&
        get_type() const;

        PositiveIntegerNillable&
        operator=(
            const PositiveIntegerNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        PositiveIntegerNillable&
        operator=(
            const IT_Bus::PositiveInteger & rhs
        );

        PositiveIntegerNillable&
        operator=(
            const IT_Bus::PositiveInteger * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NonPositiveIntegerNillable :
        public NillableValueBase<IT_Bus::NonPositiveInteger>
    {
      public:
        NonPositiveIntegerNillable();

        NonPositiveIntegerNillable(
            const NonPositiveInteger& value
        );

        virtual
        ~NonPositiveIntegerNillable();

        const QName&
        get_type() const;

        NonPositiveIntegerNillable&
        operator=(
            const NonPositiveIntegerNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NonPositiveIntegerNillable&
        operator=(
            const IT_Bus::NonPositiveInteger & rhs
        );

        NonPositiveIntegerNillable&
        operator=(
            const IT_Bus::NonPositiveInteger * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NegativeIntegerNillable :
        public NillableValueBase<IT_Bus::NegativeInteger>
    {
      public:
        NegativeIntegerNillable();

        NegativeIntegerNillable(
            const NegativeInteger& value
        );

        virtual
        ~NegativeIntegerNillable();

        const QName&
        get_type() const;

        NegativeIntegerNillable&
        operator=(
            const NegativeIntegerNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NegativeIntegerNillable&
        operator=(
            const IT_Bus::NegativeInteger & rhs
        );

        NegativeIntegerNillable&
        operator=(
            const IT_Bus::NegativeInteger * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NonNegativeIntegerNillable :
        public NillableValueBase<IT_Bus::NonNegativeInteger>
    {
      public:
        NonNegativeIntegerNillable();

        NonNegativeIntegerNillable(
            const NonNegativeInteger& value
        );

        virtual
        ~NonNegativeIntegerNillable();

        const QName&
        get_type() const;

        NonNegativeIntegerNillable&
        operator=(
            const NonNegativeIntegerNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NonNegativeIntegerNillable&
        operator=(
            const IT_Bus::NonNegativeInteger & rhs
        );

        NonNegativeIntegerNillable&
        operator=(
            const IT_Bus::NonNegativeInteger * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API QNameNillable :
        public NillableValueBase<IT_Bus::QName>
    {
      public:
        QNameNillable();

        QNameNillable(
            const QName& value
        );

        virtual
        ~QNameNillable();

        const QName&
        get_type() const;

        QNameNillable&
        operator=(
            const QNameNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        QNameNillable&
        operator=(
            const IT_Bus::QName & rhs
        );

        QNameNillable&
        operator=(
            const IT_Bus::QName * rhs
        );


        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API DateTimeNillable :
        public NillableValueBase<IT_Bus::DateTime>
    {
      public:
        DateTimeNillable();

        DateTimeNillable(
            const DateTime& value
        );

        virtual
        ~DateTimeNillable();

        const QName&
        get_type() const;

        DateTimeNillable&
        operator=(
            const DateTimeNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        DateTimeNillable&
        operator=(
            const IT_Bus::DateTime & rhs
        );

        DateTimeNillable&
        operator=(
            const IT_Bus::DateTime * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API DateNillable :
        public NillableValueBase<IT_Bus::Date>
    {
      public:
        DateNillable();

        DateNillable(
            const Date& value
        );

        virtual
        ~DateNillable();

        const QName&
        get_type() const;

        DateNillable&
        operator=(
            const DateNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        DateNillable&
        operator=(
            const IT_Bus::Date & rhs
        );

        DateNillable&
        operator=(
            const IT_Bus::Date * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API TimeNillable :
        public NillableValueBase<IT_Bus::Time>
    {
      public:
        TimeNillable();

        TimeNillable(
            const Time& value
        );

        virtual
        ~TimeNillable();

        const QName&
        get_type() const;

        TimeNillable&
        operator=(
            const TimeNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        TimeNillable&
        operator=(
            const IT_Bus::Time & rhs
        );

        TimeNillable&
        operator=(
            const IT_Bus::Time * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API GYearNillable :
        public NillableValueBase<IT_Bus::GYear>
    {
      public:
        GYearNillable();

        GYearNillable(
            const GYear& value
        );

        virtual
        ~GYearNillable();

        const QName&
        get_type() const;

        GYearNillable&
        operator=(
            const GYearNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        GYearNillable&
        operator=(
            const IT_Bus::GYear & rhs
        );

        GYearNillable&
        operator=(
            const IT_Bus::GYear * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API GYearMonthNillable :
        public NillableValueBase<IT_Bus::GYearMonth>
    {
      public:
        GYearMonthNillable();

        GYearMonthNillable(
            const GYearMonth& value
        );

        virtual
        ~GYearMonthNillable();

        const QName&
        get_type() const;

        GYearMonthNillable&
        operator=(
            const GYearMonthNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        GYearMonthNillable&
        operator=(
            const IT_Bus::GYearMonth & rhs
        );

        GYearMonthNillable&
        operator=(
            const IT_Bus::GYearMonth * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API GMonthNillable :
        public NillableValueBase<IT_Bus::GMonth>
    {
      public:
        GMonthNillable();

        GMonthNillable(
            const GMonth& value
        );

        virtual
        ~GMonthNillable();

        const QName&
        get_type() const;

        GMonthNillable&
        operator=(
            const GMonthNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        GMonthNillable&
        operator=(
            const IT_Bus::GMonth & rhs
        );

        GMonthNillable&
        operator=(
            const IT_Bus::GMonth * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API GMonthDayNillable :
        public NillableValueBase<IT_Bus::GMonthDay>
    {
      public:
        GMonthDayNillable();

        GMonthDayNillable(
            const GMonthDay& value
        );

        virtual
        ~GMonthDayNillable();

        const QName&
        get_type() const;

        GMonthDayNillable&
        operator=(
            const GMonthDayNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        GMonthDayNillable&
        operator=(
            const IT_Bus::GMonthDay & rhs
        );

        GMonthDayNillable&
        operator=(
            const IT_Bus::GMonthDay * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API GDayNillable :
        public NillableValueBase<IT_Bus::GDay>
    {
      public:
        GDayNillable();

        GDayNillable(
            const GDay& value
        );

        virtual
        ~GDayNillable();

        const QName&
        get_type() const;

        GDayNillable&
        operator=(
            const GDayNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        GDayNillable&
        operator=(
            const IT_Bus::GDay & rhs
        );

        GDayNillable&
        operator=(
            const IT_Bus::GDay * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API DurationNillable :
        public NillableValueBase<IT_Bus::Duration>
    {
      public:
        DurationNillable();

        DurationNillable(
            const Duration& value
        );

        virtual
        ~DurationNillable();

        const QName&
        get_type() const;

        DurationNillable&
        operator=(
            const DurationNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        DurationNillable&
        operator=(
            const IT_Bus::Duration & rhs
        );

        DurationNillable&
        operator=(
            const IT_Bus::Duration * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API AnyURINillable :
        public NillableValueBase<IT_Bus::AnyURI>
    {
      public:
        AnyURINillable();

        AnyURINillable(
            const AnyURI& value
        );

        virtual
        ~AnyURINillable();

        const QName&
        get_type() const;

        AnyURINillable&
        operator=(
            const AnyURINillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        AnyURINillable&
        operator=(
            const IT_Bus::AnyURI & rhs
        );

        AnyURINillable&
        operator=(
            const IT_Bus::AnyURI * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NormalizedStringNillable :
        public NillableValueBase<IT_Bus::NormalizedString>
    {
      public:
        NormalizedStringNillable();

        NormalizedStringNillable(
            const NormalizedString& value
        );

        virtual
        ~NormalizedStringNillable();

        const QName&
        get_type() const;

        NormalizedStringNillable&
        operator=(
            const NormalizedStringNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NormalizedStringNillable&
        operator=(
            const IT_Bus::NormalizedString & rhs
        );

        NormalizedStringNillable&
        operator=(
            const IT_Bus::NormalizedString * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API TokenNillable :
        public NillableValueBase<IT_Bus::Token>
    {
      public:
        TokenNillable();

        TokenNillable(
            const Token& value
        );

        virtual
        ~TokenNillable();

        const QName&
        get_type() const;

        TokenNillable&
        operator=(
            const TokenNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        TokenNillable&
        operator=(
            const IT_Bus::Token & rhs
        );

        TokenNillable&
        operator=(
            const IT_Bus::Token * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API LanguageNillable :
        public NillableValueBase<IT_Bus::Language>
    {
      public:
        LanguageNillable();

        LanguageNillable(
            const Language& value
        );

        virtual
        ~LanguageNillable();

        const QName&
        get_type() const;

        LanguageNillable&
        operator=(
            const LanguageNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        LanguageNillable&
        operator=(
            const IT_Bus::Language & rhs
        );

        LanguageNillable&
        operator=(
            const IT_Bus::Language * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NameNillable :
        public NillableValueBase<IT_Bus::Name>
    {
      public:
        NameNillable();

        NameNillable(
            const Name& value
        );

        virtual
        ~NameNillable();

        const QName&
        get_type() const;

        NameNillable&
        operator=(
            const NameNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NameNillable&
        operator=(
            const IT_Bus::Name & rhs
        );

        NameNillable&
        operator=(
            const IT_Bus::Name * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NCNameNillable :
        public NillableValueBase<IT_Bus::NCName>
    {
      public:
        NCNameNillable();

        NCNameNillable(
            const NCName& value
        );

        virtual
        ~NCNameNillable();

        const QName&
        get_type() const;

        NCNameNillable&
        operator=(
            const NCNameNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NCNameNillable&
        operator=(
            const IT_Bus::NCName & rhs
        );

        NCNameNillable&
        operator=(
            const IT_Bus::NCName * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NMTokenNillable :
        public NillableValueBase<IT_Bus::NMToken>
    {
      public:
        NMTokenNillable();

        NMTokenNillable(
            const NMToken& value
        );

        virtual
        ~NMTokenNillable();

        const QName&
        get_type() const;

        NMTokenNillable&
        operator=(
            const NMTokenNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NMTokenNillable&
        operator=(
            const IT_Bus::NMToken & rhs
        );

        NMTokenNillable&
        operator=(
            const IT_Bus::NMToken * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API NMTokensNillable :
        public NillableValueBase<IT_Bus::NMTokens>
    {
      public:
        NMTokensNillable();

        NMTokensNillable(
            const NMTokens& value
        );

        virtual
        ~NMTokensNillable();

        const QName&
        get_type() const;

        NMTokensNillable&
        operator=(
            const NMTokensNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        NMTokensNillable&
        operator=(
            const IT_Bus::NMTokens & rhs
        );

        NMTokensNillable&
        operator=(
            const IT_Bus::NMTokens * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };

    class IT_AFC_API IDNillable :
        public NillableValueBase<IT_Bus::ID>
    {
      public:
        IDNillable();

        IDNillable(
            const ID& value
        );

        virtual
        ~IDNillable();

        const QName&
        get_type() const;

        IDNillable&
        operator=(
            const IDNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        IDNillable&
        operator=(
            const IT_Bus::ID & rhs
        );

        IDNillable&
        operator=(
            const IT_Bus::ID * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API Base64Nillable :
        public NillableValueBase<IT_Bus::Base64Binary>
    {
      public:
        Base64Nillable();

        Base64Nillable(
            const Base64Binary& value
        );

        virtual
        ~Base64Nillable();

        const QName&
        get_type() const;

        Base64Nillable&
        operator=(
            const Base64Nillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        Base64Nillable&
        operator=(
            const IT_Bus::Base64Binary & rhs
        );

        Base64Nillable&
        operator=(
            const IT_Bus::Base64Binary * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    class IT_AFC_API HexNillable :
        public NillableValueBase<IT_Bus::HexBinary>
    {
      public:
        HexNillable();

        HexNillable(
            const HexBinary& value
        );

        virtual
        ~HexNillable();

        const QName&
        get_type() const;

        HexNillable&
        operator=(
            const HexNillable& rhs
        );

        AnyType&
        copy(
            const AnyType& other
        );

        HexNillable&
        operator=(
            const IT_Bus::HexBinary & rhs
        );

        HexNillable&
        operator=(
            const IT_Bus::HexBinary * rhs
        );

        virtual void
        write_value(
            const QName& name,
            ComplexTypeWriter& writer
        ) const IT_THROW_DECL((SerializationException));
    
        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));
    };


    typedef BinaryOutParamNillable<&IT_W3CConstants::NT_SCHEMA_BASE64>
        Base64BinaryOutParamNillable;

    typedef BinaryOutParamNillable<&IT_W3CConstants::NT_SCHEMA_HBIN>
        HexBinaryOutParamNillable;

    typedef BinaryInParamNillable<&IT_W3CConstants::NT_SCHEMA_BASE64>
        Base64BinaryInParamNillable;

    typedef BinaryInParamNillable<&IT_W3CConstants::NT_SCHEMA_HBIN>
        HexBinaryInParamNillable;
}

// These template instantiations are done here to workaround a bug in VC++ 7.0.
#ifdef _MSC_VER
#if _MSC_VER == 1300
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::AnyHolder>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Boolean>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Long>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::ULong>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::UInt>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Int>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Short>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::UShort>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::String>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Byte>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::UByte>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Float>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Double>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Decimal>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Integer>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::PositiveInteger>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NonPositiveInteger>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NegativeInteger>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NonNegativeInteger>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::QName>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::DateTime>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Date>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Time>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::GYear>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::GYearMonth>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::GMonth>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::GMonthDay>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::GDay>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Duration>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::AnyURI>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NormalizedString>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Token>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Language>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Name>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NCName>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NMToken>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::NMTokens>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::ID>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::Base64Binary>;
template class IT_AFC_API IT_Bus::NillableValueBase<IT_Bus::HexBinary>;
#endif
#endif /* _MSC_VER */

#endif  

---