ValueConverters.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <OnixS/CME/iLink3/messaging/String.h>
#include <OnixS/CME/iLink3/messaging/Time.h>
 
#include <OnixS/CME/iLink3/messaging/Decimal.h>
#include <OnixS/CME/iLink3/messaging/Decimal.Operations.h>
#include <OnixS/CME/iLink3/messaging/Integral.h>
#include <OnixS/CME/iLink3/messaging/Serialization.h>
 
#include <OnixS/CME/iLink3/messaging/TagBased/ValueContainer.h>
#include <OnixS/CME/iLink3/messaging/ExceptionHelpers.h>
 
ONIXS_ILINK3_MESSAGING_TAGBASED_NAMESPACE_BEGIN

ONIXS_ILINK3_EXPORTED_STRUCT
ValueConverter
{
    virtual const Char* typeName() const ONIXS_ILINK3_NOTHROW = 0;

    virtual void toStr(std::string&, const ValueContainer&) const
    {
    }

    virtual StrRef toStr(Char*, size_t, const ValueContainer&) const
    {
        throwBadConversion(typeName());
    }

    virtual bool convert(StrRef&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Char&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Int8&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(UInt8&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Int16&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(UInt16&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Int32&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(UInt32&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Int64&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(UInt64&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Decimal&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    virtual bool convert(Timestamp&, const ValueContainer&) const
    {
        return false;
    }

    virtual bool convert(MaturityMonthYear&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }
 
protected:
    ~ValueConverter() ONIXS_ILINK3_DEFAULT;
};
 
ONIXS_ILINK3_EXPORTED_STRUCT
NullConverter ONIXS_ILINK3_FINAL : ValueConverter
{
    ONIXS_ILINK3_NODISCARD const Char* typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Null";
    }
 
    ONIXS_ILINK3_NODISCARD static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~NullConverter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
StrRefConverter ONIXS_ILINK3_FINAL : ValueConverter
{
    using ValueConverter::convert;
 
    ONIXS_ILINK3_NODISCARD const Char* typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "String";
    }
 
    void
    toStr(
        std::string& str,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        ref =
            container.get<StrRef>();
 
        str.
            assign(
                ref.data(),
                ref.size());
    }
 
    StrRef
    toStr(
        Char*, size_t, const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return container.get<StrRef>();
    }
 
    bool
    convert(
        StrRef& ref,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        ref = container.get<StrRef>();
 
        return true;
    }
 
    bool
    convert(
        Char& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        if (1 == str.size())
        {
            value = str[0];
 
            return true;
        }
        else if (str.empty())
        {
            value = 0;
 
            return true;
        }
 
        return false;
    }
 
    bool
    convert(
        Int8& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        UInt8& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        Int16& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        UInt16& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        Int32& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        UInt32& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        Int64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        UInt64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        Decimal& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    bool
    convert(
        Timestamp& value,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        const
        StrRef&
        str =
            container.get<StrRef>();
 
        return
            fromStr(
                value,
                str.data(),
                str.size());
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~StrRefConverter() ONIXS_ILINK3_DEFAULT;
};
 
//

ONIXS_ILINK3_EXPORTED_STRUCT
CharConverter ONIXS_ILINK3_FINAL : ValueConverter
{
    using ValueConverter::convert;
 
    ONIXS_ILINK3_NODISCARD const Char* typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Char";
    }
 
    void
    toStr(
        std::string& str,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        str.append(
            1,
            container.get<Char>());
    }
 
    StrRef
    toStr(
        Char*, size_t, const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            StrRef(
                &container.get<Char>(),
                1);
    }
 
    bool
    convert(
        StrRef& ref,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        ref =
            StrRef(
                &container.get<Char>(),
                1);
 
        return true;
    }
 
    bool
    convert(
        Char& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value = container.get<Char>();
 
        return true;
    }
 
    bool
    convert(
        Int8& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        UInt8& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        Int16& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        UInt16& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        Int32& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        UInt32& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        Int64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        UInt64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return
            charToDigit(
                value,
                container.get<Char>());
    }
 
    bool
    convert(
        Decimal& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        Decimal::Mantissa mantissa;
 
        if (charToDigit(
            mantissa,
            container.get<Char>()))
        {
            value = Decimal(mantissa, 0);
 
            return true;
        }
 
        return false;
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~CharConverter() ONIXS_ILINK3_DEFAULT;
 
private:
    template
    <
        class Integer
    >
    static
    bool
    charToDigit(
        Integer& converted,
        Char original) ONIXS_ILINK3_NOTHROW
    {
        if ('0' <= original &&
            '9' >= original)
        {
            converted =
                static_cast
                <Integer>
                (original - '0');
 
            return true;
        }
 
        return false;
    }
};

template
<
    class Integer
>
class
IntegerConverter
: public ValueConverter
{
    template
    <
        class Integral,
        bool IsSigned
    >
    struct
    FitsToChar
    {
        bool
        operator ()(
            Integral value) const ONIXS_ILINK3_NOTHROW
        {
            return (
                0 <= value &&
                value < 10
            );
        }
    };
 
    template
    <
        class Integral
    >
    struct
    FitsToChar
    <
        Integral,
        false
    >
    {
        bool
        operator ()(
            Integral value) const ONIXS_ILINK3_NOTHROW
        {
            return (value < 10);
        }
    };
 
    typedef
    FitsToChar
    <
        Integer,
        !(
            static_cast<Integer>(-1) >
            static_cast<Integer>(0)
        )
    >
    CanFitToChar;
 
public:
    using ValueConverter::convert;
 
    void
    toStr(
        std::string& str,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        OnixS::CME::iLink3::Messaging::toStr(
            str,
            container.get<Integer>());
    }
 
    StrRef
    toStr(
        Char* buf, size_t size, const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        assert(buf);
 
        const size_t converted =
            OnixS::CME::iLink3::Messaging::toStr(
                container.get<Integer>(),
                buf,
                size);
 
        assert(converted < size);
        assert(converted != 0);
 
        return
            StrRef(buf, converted);
    }
 
    bool
    convert(
        Char& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        const
        Integer
        actual =
            container.get<Integer>();
 
        if (CanFitToChar()(actual))
        {
            value =
                static_cast
                <Char>
                ('0' + actual);
 
            return true;
        }
 
        return false;
    }
 
    bool
    convert(
        Int8& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<Int8>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        UInt8& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<UInt8>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        Int16& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<Int16>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        UInt16& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<UInt16>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        Int32& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<Int32>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        UInt32& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<UInt32>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        Int64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<Int64>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        UInt64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<UInt64>(
                container.get<Integer>());
 
        return true;
    }
 
    bool
    convert(
        Decimal& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            Decimal
            (
                numericCast<Decimal::Mantissa>(
                    container.get<Integer>()),
                0
            );
 
        return true;
    }
 
    bool
    convert(
        Timestamp& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            makeTimestamp(
                numericCast<UInt64>(
                    container.get<Integer>()));
 
        return true;
    }
 
protected:
    ~IntegerConverter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
Int8Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    Int8
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Int8";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~Int8Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
UInt8Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    UInt8
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "UInt8";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~UInt8Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
Int16Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    Int16
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Int16";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~Int16Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
UInt16Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    UInt16
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "UInt16";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~UInt16Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
Int32Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    Int32
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Int32";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~Int32Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
UInt32Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    UInt32
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "UInt32";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~UInt32Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
Int64Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    Int64
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Int64";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~Int64Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
UInt64Converter ONIXS_ILINK3_FINAL
: IntegerConverter
<
    UInt64
>
{
    ONIXS_ILINK3_NODISCARD const Char * typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "UInt64";
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~UInt64Converter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
DecimalConverter ONIXS_ILINK3_FINAL : ValueConverter
{
    using ValueConverter::convert;
 
    ONIXS_ILINK3_NODISCARD const Char* typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Decimal";
    }
 
    void
    toStr(
        std::string& str,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        OnixS::CME::iLink3::Messaging::toStr(
            str,
            container.get<Decimal>());
    }
 
    StrRef
    toStr(
        Char* buf, size_t size, const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        assert(buf);
 
        const size_t converted =
            OnixS::CME::iLink3::Messaging::toStr(
                container.get<Decimal>(),
                buf,
                size);
 
        assert(converted != 0);
        assert(converted < size);
 
        return
            StrRef(buf, converted);
    }
 
    bool
    convert(
        Decimal& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value = container.get<Decimal>();
 
        return true;
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~DecimalConverter() ONIXS_ILINK3_DEFAULT;
};
 
//

ONIXS_ILINK3_EXPORTED_STRUCT
TimestampConverter ONIXS_ILINK3_FINAL : ValueConverter
{
    using ValueConverter::convert;
 
    ONIXS_ILINK3_NODISCARD const Char* typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "Timestamp";
    }
 
    void
    toStr(
        std::string& str,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        OnixS::CME::iLink3::Messaging::toStr(
            str,
            container.get<Timestamp>());
    }
 
    StrRef
    toStr(
        Char* buf, size_t size, const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        assert(buf);
 
        const size_t converted =
            OnixS::CME::iLink3::Messaging::toStr(
                container.get<Timestamp>(),
                buf,
                size);
 
        assert(converted < size);
        assert(converted != 0);
 
        return
            StrRef(buf, converted);
    }
 
    bool
    convert(
        Int64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            numericCast<Int64>
            (
                container.
                    get<Timestamp>().
                    sinceEpoch()
            );
 
        return true;
    }
 
    bool
    convert(
        UInt64& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            container.
                get<Timestamp>().
                sinceEpoch();
 
        return true;
    }
 
    bool
    convert(
        Timestamp& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value = container.get<Timestamp>();
 
        return true;
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~TimestampConverter() ONIXS_ILINK3_DEFAULT;
};

ONIXS_ILINK3_EXPORTED_STRUCT
MaturityMonthYearConverter ONIXS_ILINK3_FINAL
: ValueConverter
{
    using ValueConverter::convert;
    using ValueConverter::toStr;
 
    ONIXS_ILINK3_NODISCARD const Char* typeName() const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        return "MaturityMonthYear";
    }
 
    void
    toStr(
        std::string& str,
        const ValueContainer& container) const ONIXS_ILINK3_OVERRIDE
    {
        OnixS::CME::iLink3::Messaging::toStr(
            str,
            container.get<MaturityMonthYear>());
    }
 
    bool
    convert(
        MaturityMonthYear& value,
        const ValueContainer& container) const ONIXS_ILINK3_NOTHROW ONIXS_ILINK3_OVERRIDE
    {
        value =
            container.
                get
                <MaturityMonthYear>
                ();
 
        return true;
    }
 
    static const ValueConverter& self() ONIXS_ILINK3_NOTHROW;
 
protected:
    ~MaturityMonthYearConverter() ONIXS_ILINK3_DEFAULT;
};

struct ValueKinds
{
    enum Enum
    {
        Ordinary,
        Enumeration,
        Bits
    };
};

template
<
    class Value
>
class ValueKind
{
    typedef
    char
    Ordinary[1];
 
    typedef
    char
    Enumeration[2];
 
    typedef
    char
    Bits[3];
 
    template
    <
        class Other
    >
    static
    Bits&
    kind(
        typename
        Other::Bits*);
 
    template
    <
        class Other
    >
    static
    Enumeration&
    kind(
        typename
        Other::Enum*);
 
    template
    <
        class Other
    >
    static
    Ordinary&
    kind(
        ...);
 
public:
    enum
    {
        Kind =
        (
            sizeof(Bits) ==
            sizeof(kind<Value>(ONIXS_ILINK3_NULLPTR))
            ? ValueKinds::Bits
            : (
                sizeof(Enumeration) ==
                sizeof(kind<Value>(ONIXS_ILINK3_NULLPTR))
                ? ValueKinds::Enumeration
                : ValueKinds::Ordinary
            )
        )
    };
};

template
<
    class Value,
    int
>
struct
ValueConversionTraits
{
    typedef Value Result;

    static Result convert(const ValueConverter& converter, const ValueContainer& container)
    {
        Result result;
 
        if (!converter.
            convert(
                result,
                container))
        {
            throwBadConversion(
                converter.typeName());
        }
 
        return result;
    }

    static bool convert(Result& result, const ValueConverter& converter, const ValueContainer& container)
    {
        return
            converter.
            convert(
                result,
                container);
    }
};

template
<
    class Enumeration
>
struct
ValueConversionTraits
<
    Enumeration,
    ValueKinds::Enumeration
>
{
    typedef
    typename
    Enumeration::Enum
    Result;

    static
    Result
    convert(
        const
        ValueConverter&
        converter,
        const
        ValueContainer&
        container)
    {
        typename
        Enumeration::Base
        result;
 
        if (!converter.
            convert(
                result,
                container))
        {
            throwBadConversion(
                converter.typeName());
        }
 
        return
            static_cast
            <Result>
            (result);
    }

    static
    bool
    convert(
        Result& result,
        const
        ValueConverter&
        converter,
        const
        ValueContainer&
        container)
    {
        typename
        Enumeration::Base
        base;
 
        if (converter.
            convert(
                base,
                container))
        {
            result =
                static_cast
                <Result>
                (base);
 
            return true;
        }
 
        return false;
    }
};

template
<
    class BitSet
>
struct
ValueConversionTraits
<
    BitSet,
    ValueKinds::Bits
>
{
    typedef BitSet Result;

    static
    BitSet
    convert(
        const
        ValueConverter&
        converter,
        const
        ValueContainer&
        container)
    {
        typename
        BitSet::Bits
        bits;
 
        if (!converter.
            convert(
                bits,
                container))
        {
            throwBadConversion(
                converter.typeName());
        }
 
        return BitSet(bits);
    }

    static
    bool
    convert(
        BitSet& result,
        const
        ValueConverter&
        converter,
        const
        ValueContainer&
        container)
    {
        typename
        BitSet::Bits
        bits;
 
        if (converter.
            convert(
                bits,
                container))
        {
            result = BitSet(bits);
 
            return true;
        }
 
        return false;
    }
};

template
<
    class Value
>
struct
ValueConversion
{
    typedef
    ValueConversionTraits
    <
        Value,
        ValueKind<Value>::Kind
    >
    Traits;

    typedef
    typename
    Traits::Result
    Result;

    typename
    Traits::Result
    operator ()(
        const ValueConverter& converter,
        const ValueContainer& container) const
    {
        return
            Traits::
                convert(
                    converter,
                    container);
    }

    bool
    operator ()(
        typename
        Traits::Result& result,
        const ValueConverter& converter,
        const ValueContainer& container) const
    {
        return
            Traits::
                convert(
                    result,
                    converter,
                    container);
    }
};
 
ONIXS_ILINK3_MESSAGING_TAGBASED_NAMESPACE_END