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

/// Abstraction gathering operations
/// over a value of a particular type
/// stored as a field in a message.
ONIXS_ILINK3_EXPORTED_STRUCT
ValueConverter
{
    /// The name of the type whose values are
    /// manipulated through the given converter.
    virtual const Char* typeName() const ONIXS_ILINK3_NOTHROW = 0;

    /// Outputs the text presentation of the value
    /// stored in the given container into the given string.
    virtual void toStr(std::string&, const ValueContainer&) const
    {
    }

    /// \return the text presentation of the value.
    virtual StrRef toStr(Char*, size_t, const ValueContainer&) const
    {
        throwBadConversion(typeName());
    }

    /// Tries to convert the value into a string reference.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(StrRef&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into a character.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Char&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Int8&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(UInt8&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Int16&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(UInt16&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Int32&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(UInt32&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Int64&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into an integer.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(UInt64&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into a Decimal.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Decimal&, const ValueContainer&) const ONIXS_ILINK3_NOTHROW
    {
        return false;
    }

    /// Tries to convert the value into a timestamp.
    ///
    /// \return Indicates whether the conversion successful.
    virtual bool convert(Timestamp&, const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value into a month-year.
    ///
    /// \return Indicates whether the conversion successful.
    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;
};

/// Implements the value conversion for text fields.
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;
};

//

/// Implements the value conversion for
/// fields whose values represent a single character.
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;
    }
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion for integer fields.
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;
};

/// Implements the value conversion the Decimal fields.
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;
};

//

/// Implements the value conversion for Timestamp fields.
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;
};

/// Implements the value conversion for month-year fields.
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;
};

/// Identifies the kind of the field value.
struct ValueKinds
{
    enum Enum
    {
        Ordinary,
        Enumeration,
        Bits
    };
};

/// Traits class used to identify a field value.
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
    {
        /// The kind of the given field value by its type.
        Kind =
        (
            sizeof(Bits) ==
            sizeof(kind<Value>(ONIXS_ILINK3_NULLPTR))
            ? ValueKinds::Bits
            : (
                sizeof(Enumeration) ==
                sizeof(kind<Value>(ONIXS_ILINK3_NULLPTR))
                ? ValueKinds::Enumeration
                : ValueKinds::Ordinary
            )
        )
    };
};

/// Field value traits used in conversion operations.
template
<
    class Value,
    int
>
struct
ValueConversionTraits
{
    /// Type of the conversion output.
    typedef Value Result;

    /// Converters the given value by using the
    /// specified value converter.
    ///
    /// \return The result of the conversion.
    ///
    /// \throw An exception in case of a conversion failure.
    static Result convert(const ValueConverter& converter, const ValueContainer& container)
    {
        Result result;

        if (!converter.
            convert(
                result,
                container))
        {
            throwBadConversion(
                converter.typeName());
        }

        return result;
    }

    /// Tries to convert the given value using
    /// the given value converter and puts the
    /// result of the conversion into the given
    /// variable.
    ///
    /// \return the conversion status.
    static bool convert(Result& result, const ValueConverter& converter, const ValueContainer& container)
    {
        return
            converter.
            convert(
                result,
                container);
    }
};

/// Field value traits used in conversion operations.
///
/// Specialization for enumerations.
template
<
    class Enumeration
>
struct
ValueConversionTraits
<
    Enumeration,
    ValueKinds::Enumeration
>
{
    /// Type of the conversion output.
    typedef
    typename
    Enumeration::Enum
    Result;

    /// Converters the given value by using the
    /// specified value converter and returns the
    /// result of conversion. Throws an exception
    /// in case of conversion failure.
    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);
    }

    /// Tries to convert the given value using
    /// the given value converter and puts the
    /// result of the conversion into the given
    /// variable. Returns conversion status.
    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;
    }
};

/// The field value traits used in
/// conversion related operations.
///
/// Specialization for bit sets.
template
<
    class BitSet
>
struct
ValueConversionTraits
<
    BitSet,
    ValueKinds::Bits
>
{
    /// Type of the conversion output.
    typedef BitSet Result;

    /// Converters the given value by using the
    /// specified value converter and returns the
    /// result of conversion. Throws an exception
    /// in case of conversion failure.
    static
    BitSet
    convert(
        const
        ValueConverter&
        converter,
        const
        ValueContainer&
        container)
    {
        typename
        BitSet::Bits
        bits;

        if (!converter.
            convert(
                bits,
                container))
        {
            throwBadConversion(
                converter.typeName());
        }

        return BitSet(bits);
    }

    /// Tries to convert the given value using
    /// the given value converter and puts the
    /// result of the conversion into the given
    /// variable. Returns conversion status.
    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;
    }
};

/// Implements value conversion operations
/// through value conversion traits.
template
<
    class Value
>
struct
ValueConversion
{
    /// Conversion traits.
    typedef
    ValueConversionTraits
    <
        Value,
        ValueKind<Value>::Kind
    >
    Traits;

    /// Conversion output type.
    typedef
    typename
    Traits::Result
    Result;

    /// Converts the given value into a value of target
    /// type. Throws an exception in case of failure.
    typename
    Traits::Result
    operator ()(
        const ValueConverter& converter,
        const ValueContainer& container) const
    {
        return
            Traits::
                convert(
                    converter,
                    container);
    }

    /// Converts the given value into a value
    /// of target type. Returns conversion status.
    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