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

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

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

    /// Tries to convert the value stored in the given 
    /// container into the string reference. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        StrRef&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the given 
    /// container into a character. The returned value 
    /// indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Char&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Int8&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        UInt8&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Int16&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        UInt16&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Int32&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        UInt32&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Int64&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into an integer. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        UInt64&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into a decimal. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Decimal&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into a timestamp. The returned 
    /// value indicates whether the conversion successful. 
    virtual 
    bool 
    convert(
        Timestamp&, 
        const ValueContainer&) const
    {
        return false;
    }

    /// Tries to convert the value stored in the 
    /// given container into a month-year. The returned 
    /// value indicates whether the conversion successful. 
    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_;
    }
};

//

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

//

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

//

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

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int8Converter 
: IntegerConverter
<
    Int8, 
    Int8Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int8";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt8Converter 
: IntegerConverter
<
    UInt8,
    UInt8Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt8";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int16Converter 
: IntegerConverter
<
    Int16,
    Int16Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int16";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt16Converter 
: IntegerConverter
<
    UInt16,
    UInt16Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt16";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int32Converter 
: IntegerConverter
<
    Int32,
    Int32Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int32";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt32Converter 
: IntegerConverter
<
    UInt32,
    UInt32Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt32";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
Int64Converter 
: IntegerConverter
<
    Int64,
    Int64Converter
>
{
    const Char* 
    typeName() const
    {
        return "Int64";
    }
};

/// Implements the value conversion 
/// abstraction for the integer fields. 
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT
UInt64Converter 
: IntegerConverter
<
    UInt64,
    UInt64Converter
>
{
    const Char* 
    typeName() const
    {
        return "UInt64";
    }
};

//

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

//

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

//

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

//

/// Identifies kinds of FIX field values. 
struct ValueKinds
{
    /// Identifies kinds of FIX field values. 
    enum Enum
    {
        Ordinary,
        Enumeration,
        Bits
    };
};

/// Traits class used identify a field value kind. 
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>(NULL)) 
            ? ValueKinds::Bits 
            : (
                sizeof(Enumeration) == 
                sizeof(kind<Value>(NULL)) 
                ? ValueKinds::Enumeration 
                : ValueKinds::Ordinary 
            )
        )
    };
};

/// The field value traits used in 
/// conversion related 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 and returns the 
    /// result of conversion. Throws an exception 
    /// in case of 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. Returns conversion status. 
    static 
    bool  
    convert(
        Result& result,
        const 
        ValueConverter& 
        converter, 
        const 
        ValueContainer& 
        container)
    {
        return 
            converter.
            convert(
                result, 
                container);
    }
};

/// The field value traits used in 
/// conversion related 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_CONFLATEDUDPFIX_NAMESPACE_END