Serialization.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 <string>
 
#include <OnixS/CME/ConflatedTCP/messaging/MDP/Messages.h>
 
 
ONIXS_CONFLATEDTCP_MESSAGING_MDP_NAMESPACE_BEGIN
 
template <typename T>
void toStr(std::string& str, T value)
{
    return Messaging::toStr(str, value);
}
 
// Market Data Serialization.

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    AggressorFlag::Enum value);
 

inline
std::string
toStr(
    AggressorFlag::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    AggressorFlag::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    AggressorFlag::Enum value)
{
    toStr(
        str,
        static_cast<AggressorFlag::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    AggressorSide::Enum value);
 

inline
std::string
toStr(
    AggressorSide::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    AggressorSide::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    AggressorSide::Enum value)
{
    toStr(
        str,
        static_cast<AggressorSide::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    MarketHrs::Enum value);
 

inline std::string toStr(MarketHrs::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    MarketHrs::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    MarketHrs::Enum value)
{
    toStr(
        str,
        static_cast<MarketHrs::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    PreviousDayFlag::Enum value);
 

inline
std::string
toStr(
    PreviousDayFlag::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    PreviousDayFlag::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    PreviousDayFlag::Enum value)
{
    toStr(
        str,
        static_cast<PreviousDayFlag::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SpectrumSecurityTradingEvent::Enum value);
 

inline
std::string
toStr(
    SpectrumSecurityTradingEvent::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SpectrumSecurityTradingEvent::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SpectrumSecurityTradingEvent::Enum value)
{
    toStr(
        str,
        static_cast<SpectrumSecurityTradingEvent::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SpectrumEntryType::Enum value);
 

inline
std::string
toStr(
    SpectrumEntryType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SpectrumEntryType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SpectrumEntryType::Enum value)
{
    toStr(
        str,
        static_cast<SpectrumEntryType::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    TickerEntryType::Enum value);
 

inline
std::string
toStr(
    TickerEntryType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    TickerEntryType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    TickerEntryType::Enum value)
{
    toStr(
        str,
        static_cast<TickerEntryType::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    EventType::Enum value);
 

inline std::string toStr(EventType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    EventType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    EventType::Enum value)
{
    toStr(
        str,
        static_cast<EventType::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    HaltReason::Enum value);
 

inline std::string toStr(HaltReason::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    HaltReason::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    HaltReason::Enum value)
{
    toStr(
        str,
        static_cast<HaltReason::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    LegSide::Enum value);
 

inline std::string toStr(LegSide::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    LegSide::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    LegSide::Enum value)
{
    toStr(
        str,
        static_cast<LegSide::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    EntryType::Enum value);
 

inline std::string toStr(EntryType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    EntryType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    EntryType::Enum value)
{
    toStr(
        str,
        static_cast<EntryType::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    EntryTypeBook::Enum value);
 

inline
std::string
toStr(
    EntryTypeBook::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    EntryTypeBook::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    EntryTypeBook::Enum value)
{
    toStr(
        str,
        static_cast<EntryTypeBook::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    EntryTypeDailyStatistics::Enum value);
 

inline
std::string
toStr(
    EntryTypeDailyStatistics::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    EntryTypeDailyStatistics::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    EntryTypeDailyStatistics::Enum value)
{
    toStr(
        str,
        static_cast<EntryTypeDailyStatistics::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    EntryTypeStatistics::Enum value);
 

inline
std::string
toStr(
    EntryTypeStatistics::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    EntryTypeStatistics::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    EntryTypeStatistics::Enum value)
{
    toStr(
        str,
        static_cast<EntryTypeStatistics::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    UpdateAction::Enum value);
 

inline std::string toStr(UpdateAction::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    UpdateAction::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    UpdateAction::Enum value)
{
    toStr(
        str,
        static_cast<UpdateAction::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    MoneyOrPar::Enum value);
 

inline std::string toStr(MoneyOrPar::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    MoneyOrPar::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    MoneyOrPar::Enum value)
{
    toStr(
        str,
        static_cast<MoneyOrPar::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    OpenCloseSettlFlag::Enum value);
 

inline
std::string
toStr(
    OpenCloseSettlFlag::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    OpenCloseSettlFlag::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    OpenCloseSettlFlag::Enum value)
{
    toStr(
        str,
        static_cast<OpenCloseSettlFlag::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    OrderUpdateAction::Enum value);
 

inline
std::string
toStr(
    OrderUpdateAction::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    OrderUpdateAction::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    OrderUpdateAction::Enum value)
{
    toStr(
        str,
        static_cast<OrderUpdateAction::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    PriceSource::Enum value);
 

inline std::string toStr(PriceSource::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    PriceSource::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    PriceSource::Enum value)
{
    toStr(
        str,
        static_cast<PriceSource::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    PutOrCall::Enum value);
 

inline std::string toStr(PutOrCall::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    PutOrCall::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    PutOrCall::Enum value)
{
    toStr(
        str,
        static_cast<PutOrCall::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    RepoSubType::Enum value);
 

inline std::string toStr(RepoSubType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    RepoSubType::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    RepoSubType::Enum value)
{
    toStr(
        str,
        static_cast<RepoSubType::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SecurityAltIDSource::Enum value);
 

inline
std::string
toStr(
    SecurityAltIDSource::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SecurityAltIDSource::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SecurityAltIDSource::Enum value)
{
    toStr(
        str,
        static_cast<SecurityAltIDSource::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SecurityTradingEvent::Enum value);
 

inline
std::string
toStr(
    SecurityTradingEvent::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SecurityTradingEvent::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SecurityTradingEvent::Enum value)
{
    toStr(
        str,
        static_cast<SecurityTradingEvent::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SecurityTradingStatus::Enum value);
 

inline
std::string
toStr(
    SecurityTradingStatus::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SecurityTradingStatus::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SecurityTradingStatus::Enum value)
{
    toStr(
        str,
        static_cast<SecurityTradingStatus::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SecurityUpdateAction::Enum value);
 

inline
std::string
toStr(
    SecurityUpdateAction::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SecurityUpdateAction::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SecurityUpdateAction::Enum value)
{
    toStr(
        str,
        static_cast<SecurityUpdateAction::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    Side::Enum value);
 

inline std::string toStr(Side::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    Side::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    Side::Enum value)
{
    toStr(
        str,
        static_cast<Side::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    WorkupTradingStatus::Enum value);
 

inline
std::string
toStr(
    WorkupTradingStatus::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    WorkupTradingStatus::Enum value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    WorkupTradingStatus::Enum value)
{
    toStr(
        str,
        static_cast<WorkupTradingStatus::Base>(value));
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    InstAttribValue set);
 

inline std::string toStr(InstAttribValue set)
{
    std::string str;
 
    toStr(str, set);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    InstAttribValue set)
{
    std::string str;
 
    toStr(str, set);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    InstAttribValue set)
{
    toStr(str, set.bits());
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    MatchEventIndicator set);
 

inline std::string toStr(MatchEventIndicator set)
{
    std::string str;
 
    toStr(str, set);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    MatchEventIndicator set)
{
    std::string str;
 
    toStr(str, set);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    MatchEventIndicator set)
{
    toStr(str, set.bits());
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    SettlPriceType set);
 

inline std::string toStr(SettlPriceType set)
{
    std::string str;
 
    toStr(str, set);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    SettlPriceType set)
{
    std::string str;
 
    toStr(str, set);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    SettlPriceType set)
{
    toStr(str, set.bits());
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    EventIndicator set);
 

inline std::string toStr(EventIndicator set)
{
    std::string str;
 
    toStr(str, set);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    EventIndicator set)
{
    std::string str;
 
    toStr(str, set);
 
    return stream << str;
}

inline
void
toFix(
    std::string& str,
    EventIndicator set)
{
    toStr(str, set.bits());
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const MaturityMonthYear& obj);
 

inline
std::string
toStr(
    const MaturityMonthYear& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const MaturityMonthYear& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const GroupSize& obj);
 

inline std::string toStr(const GroupSize& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const GroupSize& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const GroupSize8Byte& obj);
 

inline
std::string
toStr(
    const GroupSize8Byte& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const GroupSize8Byte& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const GroupSizeEncoding& obj);
 

inline
std::string
toStr(
    const GroupSizeEncoding& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const GroupSizeEncoding& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const MessageHeader& obj);
 

inline std::string toStr(const MessageHeader& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const MessageHeader& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFixedIncome57& obj);
 

inline
std::string
toStr(
    const InstrumentDefinitionFixedIncome57& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFixedIncome57& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const InstrumentDefinitionFixedIncome57& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFixedIncome57::EventsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFixedIncome57::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFixedIncome57::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFixedIncome57::FeedTypesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFixedIncome57::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFixedIncome57::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFixedIncome57::InstAttribEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFixedIncome57::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFixedIncome57::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFixedIncome57::LotTypeRulesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFixedIncome57::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFixedIncome57::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58& obj);
 

inline
std::string
toStr(
    const InstrumentDefinitionRepo58& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const InstrumentDefinitionRepo58& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::EventsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::FeedTypesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::InstAttribEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::LotTypeRulesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::UnderlyingsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::UnderlyingsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::UnderlyingsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::RelatedInstrumentsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::RelatedInstrumentsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::RelatedInstrumentsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionRepo58::BrokenDatesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionRepo58::BrokenDatesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionRepo58::BrokenDatesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotRefreshTopOrders59& obj);
 

inline
std::string
toStr(
    const SnapshotRefreshTopOrders59& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotRefreshTopOrders59& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotRefreshTopOrders59& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotRefreshTopOrders59::Entry& obj);

inline
std::string
toStr(
    const SnapshotRefreshTopOrders59::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotRefreshTopOrders59::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SecurityStatusWorkup60& obj);
 

inline
std::string
toStr(
    const SecurityStatusWorkup60& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SecurityStatusWorkup60& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SecurityStatusWorkup60& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SecurityStatusWorkup60::OrderIDEntry& obj);

inline
std::string
toStr(
    const SecurityStatusWorkup60::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SecurityStatusWorkup60::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshTCP61& obj);
 

inline
std::string
toStr(
    const SnapshotFullRefreshTCP61& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshTCP61& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotFullRefreshTCP61& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshTCP61::Entry& obj);

inline
std::string
toStr(
    const SnapshotFullRefreshTCP61::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshTCP61::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const CollateralMarketValue62& obj);
 

inline
std::string
toStr(
    const CollateralMarketValue62& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const CollateralMarketValue62& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const CollateralMarketValue62& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const CollateralMarketValue62::Entry& obj);

inline
std::string
toStr(
    const CollateralMarketValue62::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const CollateralMarketValue62::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFX63& obj);
 

inline
std::string
toStr(
    const InstrumentDefinitionFX63& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFX63& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const InstrumentDefinitionFX63& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFX63::EventsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFX63::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFX63::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFX63::FeedTypesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFX63::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFX63::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFX63::InstAttribEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFX63::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFX63::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFX63::LotTypeRulesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFX63::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFX63::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFX63::TradingSessionsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFX63::TradingSessionsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFX63::TradingSessionsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshBookLongQty64& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshBookLongQty64& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshBookLongQty64& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshBookLongQty64& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshBookLongQty64::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshBookLongQty64::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshBookLongQty64::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshBookLongQty64::OrderIDEntry& obj);

inline
std::string
toStr(
    const IncrementalRefreshBookLongQty64::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshBookLongQty64::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTradeSummaryLongQty65& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshTradeSummaryLongQty65& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTradeSummaryLongQty65& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshTradeSummaryLongQty65& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTradeSummaryLongQty65::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshTradeSummaryLongQty65::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTradeSummaryLongQty65::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTradeSummaryLongQty65::OrderIDEntry& obj);

inline
std::string
toStr(
    const IncrementalRefreshTradeSummaryLongQty65::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTradeSummaryLongQty65::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshVolumeLongQty66& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshVolumeLongQty66& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshVolumeLongQty66& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshVolumeLongQty66& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshVolumeLongQty66::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshVolumeLongQty66::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshVolumeLongQty66::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshSessionStatisticsLongQty67& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshSessionStatisticsLongQty67& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshSessionStatisticsLongQty67& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshSessionStatisticsLongQty67& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshSessionStatisticsLongQty67::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshSessionStatisticsLongQty67::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshSessionStatisticsLongQty67::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshTCPLongQty68& obj);
 

inline
std::string
toStr(
    const SnapshotFullRefreshTCPLongQty68& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshTCPLongQty68& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotFullRefreshTCPLongQty68& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshTCPLongQty68::Entry& obj);

inline
std::string
toStr(
    const SnapshotFullRefreshTCPLongQty68::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshTCPLongQty68::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshLongQty69& obj);
 

inline
std::string
toStr(
    const SnapshotFullRefreshLongQty69& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshLongQty69& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotFullRefreshLongQty69& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshLongQty69::Entry& obj);

inline
std::string
toStr(
    const SnapshotFullRefreshLongQty69::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshLongQty69::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const AdminHeartbeat302& obj);
 

inline
std::string
toStr(
    const AdminHeartbeat302& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const AdminHeartbeat302& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const AdminHeartbeat302& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshSpectrum303& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshSpectrum303& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshSpectrum303& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshSpectrum303& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshSpectrum303::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshSpectrum303::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshSpectrum303::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTicker304& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshTicker304& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTicker304& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshTicker304& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTicker304::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshTicker304::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTicker304::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotRefreshSpectrum305& obj);
 

inline
std::string
toStr(
    const SnapshotRefreshSpectrum305& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotRefreshSpectrum305& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotRefreshSpectrum305& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotRefreshSpectrum305::Entry& obj);

inline
std::string
toStr(
    const SnapshotRefreshSpectrum305::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotRefreshSpectrum305::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotRefreshTicker306& obj);
 

inline
std::string
toStr(
    const SnapshotRefreshTicker306& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotRefreshTicker306& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotRefreshTicker306& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotRefreshTicker306::Entry& obj);

inline
std::string
toStr(
    const SnapshotRefreshTicker306::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotRefreshTicker306::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const GlobalDayRoll307& obj);
 

inline
std::string
toStr(
    const GlobalDayRoll307& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const GlobalDayRoll307& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const GlobalDayRoll307& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const ChannelReset4& obj);
 

inline std::string toStr(const ChannelReset4& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const ChannelReset4& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const ChannelReset4& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const ChannelReset4::Entry& obj);

inline
std::string
toStr(
    const ChannelReset4::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const ChannelReset4::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const AdminHeartbeat12& obj);
 

inline
std::string
toStr(
    const AdminHeartbeat12& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const AdminHeartbeat12& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const AdminHeartbeat12& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const AdminLogin15& obj);
 

inline std::string toStr(const AdminLogin15& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const AdminLogin15& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const AdminLogin15& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const AdminLogout16& obj);
 

inline std::string toStr(const AdminLogout16& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const AdminLogout16& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const AdminLogout16& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFuture54& obj);
 

inline
std::string
toStr(
    const InstrumentDefinitionFuture54& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFuture54& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const InstrumentDefinitionFuture54& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFuture54::EventsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFuture54::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFuture54::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFuture54::FeedTypesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFuture54::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFuture54::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFuture54::InstAttribEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFuture54::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFuture54::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionFuture54::LotTypeRulesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionFuture54::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionFuture54::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionSpread56& obj);
 

inline
std::string
toStr(
    const InstrumentDefinitionSpread56& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionSpread56& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const InstrumentDefinitionSpread56& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionSpread56::EventsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionSpread56::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionSpread56::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionSpread56::FeedTypesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionSpread56::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionSpread56::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionSpread56::InstAttribEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionSpread56::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionSpread56::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionSpread56::LotTypeRulesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionSpread56::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionSpread56::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionSpread56::LegsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionSpread56::LegsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionSpread56::LegsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SecurityStatus30& obj);
 

inline
std::string
toStr(
    const SecurityStatus30& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SecurityStatus30& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SecurityStatus30& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshBook46& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshBook46& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshBook46& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshBook46& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshBook46::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshBook46::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshBook46::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshBook46::OrderIDEntry& obj);

inline
std::string
toStr(
    const IncrementalRefreshBook46::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshBook46::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshDailyStatistics49& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshDailyStatistics49& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshDailyStatistics49& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshDailyStatistics49& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshDailyStatistics49::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshDailyStatistics49::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshDailyStatistics49::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshLimitsBanding50& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshLimitsBanding50& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshLimitsBanding50& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshLimitsBanding50& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshLimitsBanding50::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshLimitsBanding50::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshLimitsBanding50::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshSessionStatistics51& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshSessionStatistics51& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshSessionStatistics51& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshSessionStatistics51& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshSessionStatistics51::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshSessionStatistics51::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshSessionStatistics51::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshVolume37& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshVolume37& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshVolume37& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshVolume37& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshVolume37::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshVolume37::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshVolume37::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefresh52& obj);
 

inline
std::string
toStr(
    const SnapshotFullRefresh52& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefresh52& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotFullRefresh52& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefresh52::Entry& obj);

inline
std::string
toStr(
    const SnapshotFullRefresh52::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefresh52::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const QuoteRequest39& obj);
 

inline
std::string
toStr(
    const QuoteRequest39& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const QuoteRequest39& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const QuoteRequest39& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const QuoteRequest39::RelatedSymEntry& obj);

inline
std::string
toStr(
    const QuoteRequest39::RelatedSymEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const QuoteRequest39::RelatedSymEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55& obj);
 

inline
std::string
toStr(
    const InstrumentDefinitionOption55& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const InstrumentDefinitionOption55& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55::EventsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionOption55::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55::EventsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55::FeedTypesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionOption55::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55::FeedTypesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55::InstAttribEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionOption55::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55::InstAttribEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55::LotTypeRulesEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionOption55::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55::LotTypeRulesEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55::UnderlyingsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionOption55::UnderlyingsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55::UnderlyingsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const InstrumentDefinitionOption55::RelatedInstrumentsEntry& obj);

inline
std::string
toStr(
    const InstrumentDefinitionOption55::RelatedInstrumentsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const InstrumentDefinitionOption55::RelatedInstrumentsEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTradeSummary48& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshTradeSummary48& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTradeSummary48& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshTradeSummary48& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTradeSummary48::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshTradeSummary48::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTradeSummary48::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshTradeSummary48::OrderIDEntry& obj);

inline
std::string
toStr(
    const IncrementalRefreshTradeSummary48::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshTradeSummary48::OrderIDEntry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshOrderBook47& obj);
 

inline
std::string
toStr(
    const IncrementalRefreshOrderBook47& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshOrderBook47& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const IncrementalRefreshOrderBook47& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const IncrementalRefreshOrderBook47::Entry& obj);

inline
std::string
toStr(
    const IncrementalRefreshOrderBook47::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const IncrementalRefreshOrderBook47::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshOrderBook53& obj);
 

inline
std::string
toStr(
    const SnapshotFullRefreshOrderBook53& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshOrderBook53& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}

ONIXS_CONFLATEDTCP_EXPORTED
void
toFix(
    std::string& str,
    const SnapshotFullRefreshOrderBook53& obj);
 

ONIXS_CONFLATEDTCP_EXPORTED
void
toStr(
    std::string& str,
    const SnapshotFullRefreshOrderBook53::Entry& obj);

inline
std::string
toStr(
    const SnapshotFullRefreshOrderBook53::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return str;
}

inline
std::ostream&
operator<<(
    std::ostream& stream,
    const SnapshotFullRefreshOrderBook53::Entry& obj)
{
    std::string str;
 
    toStr(str, obj);
 
    return stream << str;
}
 
ONIXS_CONFLATEDTCP_MESSAGING_MDP_NAMESPACE_END