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/iLink3/messaging/Fields.h>
#include <OnixS/CME/iLink3/messaging/Composites.h>
 
ONIXS_ILINK3_MESSAGING_NAMESPACE_BEGIN
 
// Market Data Serialization.

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    AvgPxInd::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    BooleanFlag::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    BooleanNULL::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ClearingAcctType::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    CmtaGiveUpCD::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    CrossTypeEnum::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    CustOrdHandlInst::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    CustOrderCapacity::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    DKReason::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ExecAckStatus::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ExecMode::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ExecReason::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ExecTypTrdCxl::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ExpCycle::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    FTI::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    KeepAliveLapsed::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ListUpdAct::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ManualOrdInd::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ManualOrdIndReq::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassActionOrdTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassActionResponse::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassActionScope::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassCancelTIF::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassCxlReqTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassStatusOrdTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassStatusReqTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    MassStatusTIF::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OFMOverrideReq::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OrdStatusTrd::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OrdStatusTrdCxl::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OrderEventType::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OrderStatus::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OrderType::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    OrderTypeReq::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    PartyDetailRole::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    QuoteAckStatus::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    QuoteCxlStatus::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    QuoteCxlTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    QuoteTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    RFQSide::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ReqResult::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SLEDS::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SMPI::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SecRspTyp::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ShortSaleType::Enum value);
 

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

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

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

ONIXS_ILINK3_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_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SideNULL::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SideReq::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SideTimeInForce::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    SplitMsg::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    TimeInForce::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    TradeAddendum::Enum value);
 

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

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

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

ONIXS_ILINK3_EXPORTED
void
toStr(
    std::string& str,
    ExecInst set);
 

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

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

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

ONIXS_ILINK3_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;
}
 
 
inline std::string ExecInst::toString() const
{
    return toStr(*this);
}
 
inline std::string MaturityMonthYear::toString() const
{
    return toStr(*this);
}
 
inline std::string AvgPxInd::toString(AvgPxInd::Enum value)
{
    return toStr(value);
}
 
inline std::string BooleanFlag::toString(BooleanFlag::Enum value)
{
    return toStr(value);
}
 
inline std::string BooleanNULL::toString(BooleanNULL::Enum value)
{
    return toStr(value);
}
 
inline
std::string
ClearingAcctType::toString(
    ClearingAcctType::Enum value)
{
    return toStr(value);
}
 
inline std::string CmtaGiveUpCD::toString(CmtaGiveUpCD::Enum value)
{
    return toStr(value);
}
 
inline
std::string
CrossTypeEnum::toString(
    CrossTypeEnum::Enum value)
{
    return toStr(value);
}
 
inline
std::string
CustOrdHandlInst::toString(
    CustOrdHandlInst::Enum value)
{
    return toStr(value);
}
 
inline
std::string
CustOrderCapacity::toString(
    CustOrderCapacity::Enum value)
{
    return toStr(value);
}
 
inline std::string DKReason::toString(DKReason::Enum value)
{
    return toStr(value);
}
 
inline
std::string
ExecAckStatus::toString(
    ExecAckStatus::Enum value)
{
    return toStr(value);
}
 
inline std::string ExecMode::toString(ExecMode::Enum value)
{
    return toStr(value);
}
 
inline std::string ExecReason::toString(ExecReason::Enum value)
{
    return toStr(value);
}
 
inline
std::string
ExecTypTrdCxl::toString(
    ExecTypTrdCxl::Enum value)
{
    return toStr(value);
}
 
inline std::string ExpCycle::toString(ExpCycle::Enum value)
{
    return toStr(value);
}
 
inline std::string FTI::toString(FTI::Enum value)
{
    return toStr(value);
}
 
inline
std::string
KeepAliveLapsed::toString(
    KeepAliveLapsed::Enum value)
{
    return toStr(value);
}
 
inline std::string ListUpdAct::toString(ListUpdAct::Enum value)
{
    return toStr(value);
}
 
inline std::string ManualOrdInd::toString(ManualOrdInd::Enum value)
{
    return toStr(value);
}
 
inline
std::string
ManualOrdIndReq::toString(
    ManualOrdIndReq::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassActionOrdTyp::toString(
    MassActionOrdTyp::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassActionResponse::toString(
    MassActionResponse::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassActionScope::toString(
    MassActionScope::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassCancelTIF::toString(
    MassCancelTIF::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassCxlReqTyp::toString(
    MassCxlReqTyp::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassStatusOrdTyp::toString(
    MassStatusOrdTyp::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassStatusReqTyp::toString(
    MassStatusReqTyp::Enum value)
{
    return toStr(value);
}
 
inline
std::string
MassStatusTIF::toString(
    MassStatusTIF::Enum value)
{
    return toStr(value);
}
 
inline
std::string
OFMOverrideReq::toString(
    OFMOverrideReq::Enum value)
{
    return toStr(value);
}
 
inline std::string OrdStatusTrd::toString(OrdStatusTrd::Enum value)
{
    return toStr(value);
}
 
inline
std::string
OrdStatusTrdCxl::toString(
    OrdStatusTrdCxl::Enum value)
{
    return toStr(value);
}
 
inline
std::string
OrderEventType::toString(
    OrderEventType::Enum value)
{
    return toStr(value);
}
 
inline std::string OrderStatus::toString(OrderStatus::Enum value)
{
    return toStr(value);
}
 
inline std::string OrderType::toString(OrderType::Enum value)
{
    return toStr(value);
}
 
inline std::string OrderTypeReq::toString(OrderTypeReq::Enum value)
{
    return toStr(value);
}
 
inline
std::string
PartyDetailRole::toString(
    PartyDetailRole::Enum value)
{
    return toStr(value);
}
 
inline
std::string
QuoteAckStatus::toString(
    QuoteAckStatus::Enum value)
{
    return toStr(value);
}
 
inline
std::string
QuoteCxlStatus::toString(
    QuoteCxlStatus::Enum value)
{
    return toStr(value);
}
 
inline std::string QuoteCxlTyp::toString(QuoteCxlTyp::Enum value)
{
    return toStr(value);
}
 
inline std::string QuoteTyp::toString(QuoteTyp::Enum value)
{
    return toStr(value);
}
 
inline std::string RFQSide::toString(RFQSide::Enum value)
{
    return toStr(value);
}
 
inline std::string ReqResult::toString(ReqResult::Enum value)
{
    return toStr(value);
}
 
inline std::string SLEDS::toString(SLEDS::Enum value)
{
    return toStr(value);
}
 
inline std::string SMPI::toString(SMPI::Enum value)
{
    return toStr(value);
}
 
inline std::string SecRspTyp::toString(SecRspTyp::Enum value)
{
    return toStr(value);
}
 
inline
std::string
ShortSaleType::toString(
    ShortSaleType::Enum value)
{
    return toStr(value);
}
 
inline std::string Side::toString(Side::Enum value)
{
    return toStr(value);
}
 
inline std::string SideNULL::toString(SideNULL::Enum value)
{
    return toStr(value);
}
 
inline std::string SideReq::toString(SideReq::Enum value)
{
    return toStr(value);
}
 
inline
std::string
SideTimeInForce::toString(
    SideTimeInForce::Enum value)
{
    return toStr(value);
}
 
inline std::string SplitMsg::toString(SplitMsg::Enum value)
{
    return toStr(value);
}
 
inline std::string TimeInForce::toString(TimeInForce::Enum value)
{
    return toStr(value);
}
 
inline
std::string
TradeAddendum::toString(
    TradeAddendum::Enum value)
{
    return toStr(value);
}
 
ONIXS_ILINK3_MESSAGING_NAMESPACE_END