it_bus/reflect/traits.h

#ifndef _IT_REFLECT_REFLECT_TRAITS_H_
#define _IT_REFLECT_REFLECT_TRAITS_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//
#include <it_bus/reflect/value_ref.h>
#include <it_bus/reflect/complex_value_ref.h>
#include <it_bus/any_simple_type_t.h>
#include <it_bus/types.h>
#include <it_bus/binary_type.h>
#include <it_bus/any_holder.h>
#include <it_bus/any_uri.h>

namespace IT_Reflect
{
    template <class T>
    struct Traits
    {
        typedef typename T::IT_ReflectionType ReflectionType;
        
        static Reflection*
        get_reflection(const T& data)
        {
            T& non_const = IT_CONST_CAST(T&, data);
            return non_const.get_reflection();
        }

        static Reflection*
        get_reflection(const T* data)
        {
            if (data == 0)
            {
                throw IT_Reflect::ReflectException("Cannot reflect on nil pointer");
            }
            return get_reflection(*data);
        }

        static IT_Bus::AnyType*
        clone(const T& data)
        {
            return new T(data);
        }
    };

    template<>
    struct Traits<IT_Bus::Boolean>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Boolean> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Boolean& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Boolean& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Boolean>(data);
        }
    };
    
    template<>
    struct Traits<IT_Bus::Float>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Float> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Float& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Float& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Float>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::Double>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Double> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Double& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Double& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Double>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::Int>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Int> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Int& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Int& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Int>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::UInt>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::UInt> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::UInt& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::UInt& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::UInt>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::Long>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Long> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Long& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Long& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Long>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::Short>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Short> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Short& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Short& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Short>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::ULong>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::ULong> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::ULong& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::ULong& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::ULong>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::UShort>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::UShort> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::UShort& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::UShort& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::UShort>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::Byte>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Byte> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Byte& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Byte& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Byte>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::UByte>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::UByte> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::UByte& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::UByte& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::UByte>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::String>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::String> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::String& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::String& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::String>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::DateTime>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::DateTime> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::DateTime& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::DateTime& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::DateTime>(data);
        }
    };

    template <>
    struct Traits<IT_Bus::Decimal>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Decimal> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Decimal& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Decimal& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Decimal>(data);
        }
    };

    template <>
    struct Traits<IT_Bus::Base64Binary>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::Base64Binary> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::Base64Binary& data)
        {
            return new ReflectionType(data);
        }

        static Reflection*
        get_reflection(const IT_Bus::Base64Binary* data)
        {
            return new ReflectionType(*data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::Base64Binary& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::Base64Binary>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::HexBinary>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::HexBinary> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::HexBinary& data)
        {
            return new ReflectionType(data);
        }

        static Reflection*
        get_reflection(const IT_Bus::HexBinary* data)
        {
            return new ReflectionType(*data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::HexBinary& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::HexBinary>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::QName>
    {
        typedef IT_Reflect::ValueRef<IT_Bus::QName> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::QName& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::QName& data)
        {
            return new IT_Bus::AnySimpleTypeT<IT_Bus::QName>(data);
        }
    };

    template<>
    struct Traits<IT_Bus::AnyHolder>
    {
        typedef IT_Reflect::ComplexValueRef<IT_Bus::AnyHolder> ReflectionType;

        static Reflection*
        get_reflection(const IT_Bus::AnyHolder& data)
        {
            return new ReflectionType(data);
        }

        static IT_Bus::AnyType*
        clone(const IT_Bus::AnyHolder& data)
        {
            return new IT_Bus::AnyHolder(data);
        }
    };
}

#endif  

---