it_bus/schema_type_traits.h

#ifndef _IT_BUS_SCHEMA_TYPE_TRAITS_H_
#define _IT_BUS_SCHEMA_TYPE_TRAITS_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//
#include <it_bus/types.h>
#include <it_bus/binary_type.h>
#include <it_bus/any_holder.h>
#include <it_bus/any_uri.h>
#include <it_bus/date.h>
#include <it_bus/gday.h>
#include <it_bus/gmonth.h>
#include <it_bus/gmonthday.h>
#include <it_bus/gyear.h>
#include <it_bus/gyearmonth.h>
#include <it_bus/duration.h>
#include <it_bus/integer.h>
#include <it_bus/time.h>
#include <it_bus/normalized_string.h>
#include <it_bus/token.h>
#include <it_bus/language.h>
#include <it_bus/name.h>
#include <it_bus/ncname.h>
#include <it_bus/nmtoken.h>
#include <it_bus/id.h>
#include <it_bus/any.h>
#include <it_bus/any_holder.h>
#include <it_schema_model/w3c_constants.h>
#include <it_bus/reflect/built_in_type.h>

namespace IT_Bus
{
    // Generic template covers built-in types.
    template <class T>
    struct SchemaTypeTraits
    {
        static const QName&
        type_name()
        {
            return T::get_static_type();
        }
    };
    
    // Specializations for built-in types.
    template<>
    struct SchemaTypeTraits<Boolean>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_BOOLEAN;
        }
        enum { value_kind = IT_Reflect::BuiltInType::BOOLEAN };
    };
    
    template<>
    struct SchemaTypeTraits<Float>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_FLOAT;
        }
        enum { value_kind = IT_Reflect::BuiltInType::FLOAT };
    };

    template<>
    struct SchemaTypeTraits<Double>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_DOUBLE;
        }
        enum { value_kind = IT_Reflect::BuiltInType::DOUBLE };
    };

    template<>
    struct SchemaTypeTraits<Int>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_INT;
        }
        enum { value_kind = IT_Reflect::BuiltInType::INT };
    };

    template<>
    struct SchemaTypeTraits<UInt>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_UINT;
        }
        enum { value_kind = IT_Reflect::BuiltInType::UINT };
    };

    template<>
    struct SchemaTypeTraits<Long>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_LONG;
        }
        enum { value_kind = IT_Reflect::BuiltInType::LONG };
    };

    template<>
    struct SchemaTypeTraits<Short>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_SHORT;
        }
        enum { value_kind = IT_Reflect::BuiltInType::SHORT };
    };

    template<>
    struct SchemaTypeTraits<ULong>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_ULONG;
        }
        enum { value_kind = IT_Reflect::BuiltInType::ULONG };
    };

    template<>
    struct SchemaTypeTraits<UShort>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_USHORT;
        }
        enum { value_kind = IT_Reflect::BuiltInType::USHORT };
    };

    template<>
    struct SchemaTypeTraits<Byte>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_BYTE;
        }
        enum { value_kind = IT_Reflect::BuiltInType::BYTE };
    };

    template<>
    struct SchemaTypeTraits<UByte>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_UBYTE;
        }
        enum { value_kind = IT_Reflect::BuiltInType::UBYTE };
    };

    template<>
    struct SchemaTypeTraits<String>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_STRING;
        }
        enum { value_kind = IT_Reflect::BuiltInType::STRING };
    };

    template<>
    struct SchemaTypeTraits<DateTime>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_DATETIME;
        }
        enum { value_kind = IT_Reflect::BuiltInType::DATETIME };
    };

    template <>
    struct SchemaTypeTraits<Decimal>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_DECIMAL;
        }
        enum { value_kind = IT_Reflect::BuiltInType::DECIMAL };
    };

    template <>
    struct SchemaTypeTraits<Base64Binary>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_BASE64;
        }
        enum { value_kind = IT_Reflect::BuiltInType::BASE64BINARY };
    };

    template<>
    struct SchemaTypeTraits<HexBinary>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_HBIN;
        }
        enum { value_kind = IT_Reflect::BuiltInType::HEXBINARY };
    };

    // Treat a raw binary buffer as base64.
    // 
    template <>
    struct SchemaTypeTraits<BinaryBuffer>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_BASE64;
        }
        enum { value_kind = IT_Reflect::BuiltInType::BASE64BINARY };
    };

    template<>
    struct SchemaTypeTraits<QName>
    {
        static const QName&
        type_name()
        {
            return IT_W3CConstants::NT_SCHEMA_QNAME;
        }
        enum { value_kind = IT_Reflect::BuiltInType::QNAME };
    };

    template <>
    struct SchemaTypeTraits<AnyURI>
    {
        static const QName&
        type_name()
        {
            return AnyURI::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::ANYURI };
    };
    
    template <>
    struct SchemaTypeTraits<Date>
    {
        static const QName&
        type_name()
        {
            return Date::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::DATE };
    };
    
    template <>
    struct SchemaTypeTraits<GDay>
    {
        static const QName&
        type_name()
        {
            return GDay::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::GDAY };
    };
    
    template <>
    struct SchemaTypeTraits<Duration>
    {
        static const QName&
        type_name()
        {
            return Duration::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::DURATION };
    };
    
    template <>
    struct SchemaTypeTraits<GMonth>
    {
        static const QName&
        type_name()
        {
            return GMonth::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::GMONTH };
    };
    
    template <>
    struct SchemaTypeTraits<GMonthDay>
    {
        static const QName&
        type_name()
        {
            return GMonthDay::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::GMDAY };
    };
    
    template <>
    struct SchemaTypeTraits<GYear>
    {
        static const QName&
        type_name()
        {
            return GYear::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::GYEAR };        
    };
    
    template <>
    struct SchemaTypeTraits<GYearMonth>
    {
        static const QName&
        type_name()
        {
            return GYearMonth::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::GYMON };        
    };
    
    template <>
    struct SchemaTypeTraits<Integer>
    {
        static const QName&
        type_name()
        {
            return Integer::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::INTEGER };        
    };
    
    template <>
    struct SchemaTypeTraits<Time>
    {
        static const QName&
        type_name()
        {
            return Time::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::TIME };
    };
    
    template <>
    struct SchemaTypeTraits<NormalizedString>
    {
        static const QName&
        type_name()
        {
            return NormalizedString::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NSTRING };        
    };
    
    template <>
    struct SchemaTypeTraits<Token>
    {
        static const QName&
        type_name()
        {
            return Token::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::TOKEN };        
    };
    
    template <>
    struct SchemaTypeTraits<Language>
    {
        static const QName&
        type_name()
        {
            return Language::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::LANG };        
    };
    
    template <>
    struct SchemaTypeTraits<Name>
    {
        static const QName&
        type_name()
        {
            return Name::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NAME };        
    };
    
    template <>
    struct SchemaTypeTraits<NCName>
    {
        static const QName&
        type_name()
        {
            return NCName::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NCNAME };        
    };
    
    template <>
    struct SchemaTypeTraits<NMToken>
    {
        static const QName&
        type_name()
        {
            return NMToken::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NMTOKEN };        
    };
    
    template <>
    struct SchemaTypeTraits<ID>
    {
        static const QName&
        type_name()
        {
            return ID::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::ID };        
    };
    
    template <>
    struct SchemaTypeTraits<PositiveInteger>
    {
        static const QName&
        type_name()
        {
            return PositiveInteger::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::PINT };
    };
    
    template <>
    struct SchemaTypeTraits<NonPositiveInteger>
    {
        static const QName&
        type_name()
        {
            return NonPositiveInteger::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NPINT };        
    };
    
    template <>
    struct SchemaTypeTraits<NegativeInteger>
    {
        static const QName&
        type_name()
        {
            return NegativeInteger::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NINT };
    };
    
    template <>
    struct SchemaTypeTraits<NonNegativeInteger>
    {
        static const QName&
        type_name()
        {
            return NonNegativeInteger::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::NNINT };
    };

    template <>
    struct SchemaTypeTraits<Any>
    {
        static const QName&
        type_name()
        {
            return Any::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::ANY };
    };

    template <>
    struct SchemaTypeTraits<AnyList>
    {
        static const QName&
        type_name()
        {
            return Any::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::ANY_LIST };
    };

    template <>
    struct SchemaTypeTraits<AnyHolder>
    {
        static const QName&
        type_name()
        {
            return AnyHolder::get_static_type();
        }
        enum { value_kind = IT_Reflect::BuiltInType::ANY_HOLDER };
    };

}

#endif  

---