it_bus_pdk/built_in_type.h

#ifndef _IT_BUS_BUILIT_IN_TYPE_H_
#define _IT_BUS_BUILIT_IN_TYPE_H_

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

#ifndef IT_MINIMISE_INCLUDES
#include <it_bus/binary_type.h>
#include <it_bus/qname.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#endif
#include <it_bus/types.h>
#include <it_schema_model/w3c_constants.h>
#include <it_bus/reflect/value_ref.h>

namespace IT_Bus
{
    class QName;
    template <class T, const QName* TYPE>
    class BuiltInType : public AnyType
    {
      public:
        typedef T ValueType;

        BuiltInType();

        BuiltInType(
            const BuiltInType& other
        );

        explicit BuiltInType(
            const T& other
        );

        virtual
        ~BuiltInType();

        virtual Kind
        get_kind() const;

        BuiltInType&
        operator=(
            const BuiltInType& other
        );

        AnyType&
        copy(
            const AnyType& other
        );

        virtual const QName&
        get_type() const;

        virtual void 
        write(
            const QName& name,
            ComplexTypeWriter& writer
        ) const throw((SerializationException));

        virtual void
        read(
            const QName& name,
            ComplexTypeReader& reader
        ) throw((DeserializationException));

        virtual const T&
        get() const;
        
        virtual T&
        get();
        
        virtual void
        set(
            const T& data
        );

        virtual IT_Reflect::Reflection*
        get_reflection() throw(());

        virtual const IT_Reflect::Reflection*
        get_reflection() const throw(());

      private:
        typedef BuiltInType ThisType; // needed for DYNAMIC_CAST macro
        T       m_data;
    };


    template <class T, const QName* TYPE>
    BuiltInType<T,TYPE>::BuiltInType() 
    {
        // Complete.
    }

    template <class T, const QName* TYPE>
    BuiltInType<T,TYPE>::BuiltInType(
        const BuiltInType<T,TYPE>& other
    ) : m_data(other.m_data)
    {
        // Complete.
    }

    template <class T, const QName* Q>
    BuiltInType<T,Q>::BuiltInType(
        const T& data
    ) : m_data(data)
    {
        // Complete.
    }

    template <class T, const QName* TYPE>
    BuiltInType<T,TYPE>::~BuiltInType()
    {
        // Complete.
    }

    template <class T, const QName* TYPE>
    BuiltInType<T,TYPE>&
    BuiltInType<T,TYPE>::operator=(
        const BuiltInType<T,TYPE>& other
    ) 
    {
        set(other.get());
        return *this;
    }

    template <class T, const QName* TYPE>
    AnyType&
    BuiltInType<T,TYPE>::copy(
        const AnyType& rhs
    ) 
    {
        const ThisType& other = IT_DYNAMIC_CAST(const ThisType&, rhs);
        *this = other;
        return *this;
    }

    template <class T, const QName* TYPE>
    AnyType::Kind
    BuiltInType<T,TYPE>::get_kind() const
    {
        return BUILT_IN;
    }

    template <class T, const QName* TYPE>
    const QName&
    BuiltInType<T,TYPE>::get_type() const
    {
        return *TYPE;
    }

    template <class T, const QName* TYPE>
    void
    BuiltInType<T,TYPE>::write(
        const QName& element_name,
        ComplexTypeWriter& writer
    ) const throw((SerializationException)) 
    {
        writer.write(element_name, m_data);
    }

    template <class T, const QName* TYPE>
    void
    BuiltInType<T,TYPE>::read(
        const QName& name,
        ComplexTypeReader& reader
    ) throw((DeserializationException))
    {
        reader.read(name, m_data);
    }

    template <class T, const QName* TYPE>    
    T&
    BuiltInType<T,TYPE>::get() 
    {
        return m_data;
    }

    template <class T, const QName* TYPE>    
    const T&
    BuiltInType<T,TYPE>::get() const 
    {
        return m_data;
    }

    template <class T, const QName* TYPE>
    void
    BuiltInType<T,TYPE>::set(
        const T& data
    )
    {
        m_data=data;
    }

    template <class T, const QName* TYPE>
    IT_Reflect::Reflection*
    BuiltInType<T,TYPE>::get_reflection() throw(())
    {
        IT_Reflect::ValueRef<T>* val_ref = new IT_Reflect::ValueRef<T>(m_data);
        return val_ref;
    }
    
    template <class T, const QName* TYPE>
    const IT_Reflect::Reflection*
    BuiltInType<T,TYPE>::get_reflection() const throw(())
    {
        const IT_Reflect::ValueRef<T>* val_ref = new IT_Reflect::ValueRef<T>(m_data);
        return val_ref;
    }

    typedef BuiltInType<IT_Bus::Boolean, &IT_W3CConstants::NT_SCHEMA_BOOLEAN>
        BooleanHolder;

    typedef BuiltInType<IT_Bus::Byte, &IT_W3CConstants::NT_SCHEMA_BYTE>
        ByteHolder;

    typedef BuiltInType<IT_Bus::Short, &IT_W3CConstants::NT_SCHEMA_SHORT>
        ShortHolder;

    typedef BuiltInType<IT_Bus::Int, &IT_W3CConstants::NT_SCHEMA_INT>
        IntHolder;

    typedef BuiltInType<IT_Bus::Long, &IT_W3CConstants::NT_SCHEMA_LONG>
        LongHolder;

    typedef BuiltInType<IT_Bus::String, &IT_W3CConstants::NT_SCHEMA_STRING>
        StringHolder;

    typedef BuiltInType<IT_Bus::Float, &IT_W3CConstants::NT_SCHEMA_FLOAT>
        FloatHolder;

    typedef BuiltInType<IT_Bus::Double, &IT_W3CConstants::NT_SCHEMA_DOUBLE>
        DoubleHolder;

    typedef BuiltInType<IT_Bus::UByte, &IT_W3CConstants::NT_SCHEMA_UBYTE>
        UByteHolder;

    typedef BuiltInType<IT_Bus::UShort, &IT_W3CConstants::NT_SCHEMA_USHORT>
        UShortHolder;

    typedef BuiltInType<IT_Bus::UInt, &IT_W3CConstants::NT_SCHEMA_UINT>
        UIntHolder;

    typedef BuiltInType<IT_Bus::ULong, &IT_W3CConstants::NT_SCHEMA_ULONG>
        ULongHolder;

    typedef BuiltInType<IT_Bus::Decimal, &IT_W3CConstants::NT_SCHEMA_DECIMAL>
        DecimalHolder;

    typedef BuiltInType<IT_Bus::QName, &IT_W3CConstants::NT_SCHEMA_QNAME>
        QNameHolder;

    typedef BuiltInType<IT_Bus::DateTime, &IT_W3CConstants::NT_SCHEMA_DATETIME>
        DateTimeHolder;

    typedef BuiltInType<IT_Bus::HexBinary, &IT_W3CConstants::NT_SCHEMA_HBIN>
        HexBinaryHolder;

    typedef BuiltInType<IT_Bus::Base64Binary, &IT_W3CConstants::NT_SCHEMA_BASE64>
        Base64BinaryHolder;
}

#endif  

---