SerializationUtils.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 <sstream>

#include <OnixS/SgxTitan/MarketData/Itch/String.h>

#include "NamespaceHelper.h"

ONIXS_HANDLER_NAMESPACE_BEGIN

// Boolean values serialization. 

inline 
void
boolToStr(
    std::string& str,
    bool value)
{
    str += (value ? "true" : "false");
}

// Container serialization. 

template
<
    class Item
>
inline 
void 
itemToStr(
    std::string& str, 
    const Item& item)
{
    toStr(str, item);
}

inline
void
itemToStr(
    std::string& str,
    const std::string& item)
{
    str += item;
}

template
<
    class Iterator
>
inline 
void
containerToStr(
    std::string& str,
    Iterator containerBegin,
    Iterator containerEnd,
    const std::string& delimiter = ",")
{
    bool addDelimiter = false;

    while (
        containerBegin != containerEnd)
    {
        if (addDelimiter) 
            str += delimiter;

        addDelimiter = true;

        itemToStr(
            str, 
            *containerBegin);

        ++containerBegin;
    }
}

// Enumeration type serialization. 

template
<
    class Constant
>
void
throwOutOfEnumRange(
    const Char* enumeration,
    Constant constant)
{
    std::string reason;

    reason += 
        "Cannot convert constant to/from text "
        "because it's out of a valid range "
        "[enumType=";

    reason += enumeration;
    reason += ",constant=";
        
    toStr(reason, constant);

    reason += "]. ";

    throw std::out_of_range(reason);
}

ONIXS_HANDLER_NAMESPACE_END

#define \
    ONIXS_ENUM_TO_STR_BEGIN(Enumeration) \
    void \
    toStr( \
        std::string& str, \
        Enumeration::Enum value) \
    { \
        typedef \
        Enumeration \
        Values; \
        \
        switch (value) \
        { 

#define \
    ONIXS_ENUM_TO_STR_ENTRY(Value) \
        case Values::Value: \
            str += #Value ; \
            break;

#define \
    ONIXS_ENUM_TO_STR_CUSTOM_ENTRY(Value, Str) \
        case Values::Value: \
            str += Str; \
            break;

#define \
    ONIXS_ENUM_TO_STR_END(Enumeration) \
        default: \
            std::stringstream ss;\
            ss << value;\
            str += "Undefined("; \
            str += ss.str(); \
            str += ")" ; \
        } \
    }

#define \
    ONIXS_STR_TO_ENUM_BEGIN(Enumeration) \
    Enumeration::Enum \
    strTo##Enumeration( \
        const std::string& str) \
    { \
        typedef \
        Enumeration \
        Values; 

#define \
    ONIXS_STR_TO_ENUM_ENTRY(Value) \
        if (str == #Value) \
            return Values::Value;

#define \
    ONIXS_STR_TO_ENUM_CUSTOM_ENTRY(Value, Str) \
        if (str == Str) \
            return Values::Value;

#define \
    ONIXS_STR_TO_ENUM_END(Enumeration) \
        throwOutOfEnumRange( \
            #Enumeration, \
            str); \
        \
        return \
            static_cast \
            <Enumeration::Enum> \
            (0); \
    }

#define \
    ONIXS_FROM_STR_BEGIN(Enumeration) \
    bool \
    fromStr( \
        Enumeration::Enum& value,\
        const Char* str, \
        size_t size) \
    { \
        typedef \
        Enumeration \
        Values; \
    \
        const StrRef strRef(str, size); 

#define \
    ONIXS_FROM_STR_ENTRY(Value) \
        if (strRef == #Value) \
        { \
            value = Values::Value; \
         \
            return true; \
        }

#define \
    ONIXS_FROM_STR_CUSTOM_ENTRY(Value, Str) \
        if (strRef == Str) \
        { \
            value = Values::Value; \
         \
            return true; \
        }

#define \
    ONIXS_FROM_STR_END(Enumeration) \
        return false; \
    }

#define \
    ONIXS_DECLARE_T0_STR_FUNCTIONS(Type) \
    void toStr(std::string&, Type);\
    inline std::string toStr(Type value)\
    {\
        std::string str;\
        toStr(str, value);\
        return str;\
    }