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 <stdexcept>
 
#include <OnixS/CME/ConflatedUDP/String.h>
#include <OnixS/CME/ConflatedUDP/Time.h>
 
#include <OnixS/CME/ConflatedUDP/Decimal.h>
#include <OnixS/CME/ConflatedUDP/Integral.h>
#include <OnixS/CME/ConflatedUDP/Serialization.h>
 
#include <OnixS/CME/ConflatedUDP/FIX/ValueContainer.h>
 
ONIXS_CONFLATEDUDPFIX_NAMESPACE_BEGIN

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    virtual 
    bool 
    convert(
        MaturityMonthYear&,
        const ValueContainer&) const
    {
        return false;
    }
};
 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
NullConverter : ValueConverter
{
    const Char* 
    typeName() const
    {
        return "Null";
    }
 
    static 
    const 
    ValueConverter& 
    self() 
    {
        static 
        const 
        NullConverter 
        self_;
 
        return self_;
    }
};
 
//

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
StrRefConverter : ValueConverter
{
    const Char* 
    typeName() const
    {
        return "String";
    }
 
    void  
    toStr(
        std::string& str, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        ref = 
            container.get<StrRef>();
 
        str.
            assign(
                ref.items(), 
                ref.size());
    }
 
    bool   
    convert(
        StrRef& ref, 
        const ValueContainer& container) const
    {
        ref = container.get<StrRef>();
        
        return true;
    }
 
    bool 
    convert(
        Char& value, 
        const ValueContainer& container) const
    {
        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
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        UInt8& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        Int16& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        UInt16& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        Int32& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        UInt32& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        Int64& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        UInt64& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        Decimal& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    bool 
    convert(
        Timestamp& value, 
        const ValueContainer& container) const
    {
        const 
        StrRef& 
        str = 
            container.get<StrRef>();
 
        return 
            fromStr(
                value, 
                str.items(), 
                str.size());
    }
 
    static 
    const 
    ValueConverter& 
    self() 
    {
        static 
        const 
        StrRefConverter 
        self_;
 
        return self_;
    }
};
 
//

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

template
<
    class Integer,
    class Descendant
>
class  
IntegerConverter 
: public ValueConverter
{
    template
    <
        class Integral,
        bool IsSigned
    >
    struct 
    FitsToChar
    {
        bool 
        operator ()(
            Integral value) const
        {
            return (
                0 <= value && 
                value < 10
            );
        }
    };
 
    template
    <
        class Integral
    >
    struct 
    FitsToChar
    <
        Integral, 
        false
    >
    {
        bool 
        operator ()(
            Integral value) const
        {
            return (value < 10);
        }
    };
 
    typedef 
    FitsToChar
    <
        Integer, 
        !(
            static_cast<Integer>(-1) > 
            static_cast<Integer>(0)
        )
    >
    CanFitToChar;
 
public:
 
    void 
    toStr(
        std::string& str, 
        const ValueContainer& container) const
    {
        OnixS::CME::ConflatedUDP::toStr(
            str, 
            container.get<Integer>());
    }
 
    bool 
    convert(
        Char& value, 
        const ValueContainer& container) const
    {
        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
    {
        value = 
            static_cast
            <Int8>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        UInt8& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <UInt8>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        Int16& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <Int16>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        UInt16& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <UInt16>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        Int32& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <Int32>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        UInt32& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <UInt32>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        Int64& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <Int64>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        UInt64& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <UInt64>
            (container.get<Integer>());
 
        return true;
    }
 
    bool 
    convert(
        Decimal& value, 
        const ValueContainer& container) const
    {
        value = 
            Decimal
            (
                static_cast<Decimal::Mantissa>
                (container.get<Integer>()), 
                0
            );
 
        return true;
    }
 
    static 
    const 
    ValueConverter& 
    self() 
    {
        static 
        const 
        Descendant
        self_;
 
        return self_;
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int8Converter 
: IntegerConverter
<
    Int8, 
    Int8Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int8";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt8Converter 
: IntegerConverter
<
    UInt8,
    UInt8Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt8";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int16Converter 
: IntegerConverter
<
    Int16,
    Int16Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int16";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt16Converter 
: IntegerConverter
<
    UInt16,
    UInt16Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt16";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int32Converter 
: IntegerConverter
<
    Int32,
    Int32Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int32";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt32Converter 
: IntegerConverter
<
    UInt32,
    UInt32Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt32";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int64Converter 
: IntegerConverter
<
    Int64,
    Int64Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int64";
    }
};

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt64Converter 
: IntegerConverter
<
    UInt64,
    UInt64Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt64";
    }
};
 
//

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
DecimalConverter : ValueConverter
{
    const Char* 
    typeName() const
    {
        return "Decimal";
    }
 
    void  
    toStr(
        std::string& str, 
        const ValueContainer& container) const
    {
        OnixS::CME::ConflatedUDP::toStr(
            str,
            container.get<Decimal>());
    }
 
    bool 
    convert(
        Decimal& value, 
        const ValueContainer& container) const
    {
        value = container.get<Decimal>();
 
        return true;
    }
 
    static 
    const 
    ValueConverter& 
    self() 
    {
        static 
        const 
        DecimalConverter 
        self_;
 
        return self_;
    }
};
 
//

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
TimestampConverter : ValueConverter
{
    const Char* 
    typeName() const
    {
        return "Timestamp";
    }
 
    void 
    toStr(
        std::string& str, 
        const ValueContainer& container) const
    {
        OnixS::CME::ConflatedUDP::toStr(
            str,
            container.get<Timestamp>());
    }
 
    bool 
    convert(
        Int64& value, 
        const ValueContainer& container) const
    {
        value = 
            static_cast
            <Int64>
            (
                container.
                    get<Timestamp>().
                    sinceEpoch()
            );
 
        return true;
    }
 
    bool 
    convert(
        UInt64& value, 
        const ValueContainer& container) const
    {
        value = 
            container.
                get<Timestamp>().
                sinceEpoch();
 
        return true;
    }
 
    bool 
    convert(
        Timestamp& value, 
        const ValueContainer& container) const
    {
        value = container.get<Timestamp>();
 
        return true;
    }
 
    static 
    const 
    ValueConverter& 
    self() 
    {
        static 
        const 
        TimestampConverter 
        self_;
 
        return self_;
    }
};
 
//

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT 
MaturityMonthYearConverter 
: ValueConverter
{
    const Char* 
    typeName() const
    {
        return "MaturityMonthYear";
    }
 
    void 
    toStr(
        std::string& str, 
        const ValueContainer& container) const
    {
        OnixS::CME::ConflatedUDP::toStr(
            str,
            container.get<MaturityMonthYear>());
    }
 
    bool 
    convert(
        MaturityMonthYear& value, 
        const ValueContainer& container) const
    {
        value = 
            container.
                get
                <MaturityMonthYear>
                ();
 
        return true;
    }
 
    static 
    const 
    ValueConverter& 
    self() 
    {
        static 
        const 
        MaturityMonthYearConverter 
        self_;
 
        return self_;
    }
};
 
// 
 
inline
void
throwBadConversion(
    const Char* typeName)
{
    std::string issue;
 
    issue += "Cannot transform ";
    
    issue += 
        typeName 
        ? typeName 
        : "Unknown type";
    
    issue += 
        " value to the value of the requested "
        "type because either conversion between "
        "types does not exist or the value cannot "
        "be fit to the value of the target type. ";
 
    throw std::domain_error(issue);
}
 
//

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>(NULL)) 
            ? ValueKinds::Bits 
            : (
                sizeof(Enumeration) == 
                sizeof(kind<Value>(NULL)) 
                ? 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_CONFLATEDUDPFIX_NAMESPACE_END