blpapi_eventformatter.h

Go to the documentation of this file.

/* Copyright 2012. Bloomberg Finance L.P.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:  The above
 * copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#ifndef INCLUDED_BLPAPI_EVENTFORMATTER
#define INCLUDED_BLPAPI_EVENTFORMATTER

#include <blpapi_call.h>
#include <blpapi_defs.h>
#include <blpapi_event.h>
#include <blpapi_topic.h>
#include <blpapi_types.h>

#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

BLPAPI_EXPORT
blpapi_EventFormatter_t *blpapi_EventFormatter_create(blpapi_Event_t *event);

BLPAPI_EXPORT
void blpapi_EventFormatter_destroy(blpapi_EventFormatter_t *victim);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendMessage(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        blpapi_Name_t *typeName,
        const blpapi_Topic_t *topic);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendMessageSeq(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        blpapi_Name_t *typeName,
        const blpapi_Topic_t *topic,
        unsigned int sequenceNumber,
        unsigned int);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendResponse(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        blpapi_Name_t *typeName);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendRecapMessage(
        blpapi_EventFormatter_t *formatter,
        const blpapi_Topic_t *topic,
        const blpapi_CorrelationId_t *cid);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendRecapMessageSeq(
        blpapi_EventFormatter_t *formatter,
        const blpapi_Topic_t *topic,
        const blpapi_CorrelationId_t *cid,
        unsigned int sequenceNumber,
        unsigned int);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendFragmentedRecapMessage(
        blpapi_EventFormatter_t *formatter,
        const char *typeString,
        blpapi_Name_t *typeName,
        const blpapi_Topic_t *topic,
        const blpapi_CorrelationId_t *cid,
        int fragmentType);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendFragmentedRecapMessageSeq(
        blpapi_EventFormatter_t *formatter,
        const char *typeString,
        blpapi_Name_t *typeName,
        const blpapi_Topic_t *topic,
        int fragmentType,
        unsigned int sequenceNumber);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueBool(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        blpapi_Bool_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueChar(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        char value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueInt32(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        blpapi_Int32_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueInt64(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        blpapi_Int64_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueFloat32(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        blpapi_Float32_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueFloat64(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        blpapi_Float64_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueDatetime(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        const blpapi_Datetime_t *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueHighPrecisionDatetime(
        blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        const blpapi_HighPrecisionDatetime_t *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueString(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        const char *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueFromName(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        const blpapi_Name_t *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueBytes(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName,
        const char *value,
        size_t length);

BLPAPI_EXPORT
int blpapi_EventFormatter_setValueNull(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName);

BLPAPI_EXPORT
int blpapi_EventFormatter_pushElement(blpapi_EventFormatter_t *formatter,
        const char *typeString,
        const blpapi_Name_t *typeName);

BLPAPI_EXPORT
int blpapi_EventFormatter_popElement(blpapi_EventFormatter_t *formatter);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueBool(
        blpapi_EventFormatter_t *formatter, blpapi_Bool_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueChar(
        blpapi_EventFormatter_t *formatter, char value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueInt32(
        blpapi_EventFormatter_t *formatter, blpapi_Int32_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueInt64(
        blpapi_EventFormatter_t *formatter, blpapi_Int64_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueFloat32(
        blpapi_EventFormatter_t *formatter, blpapi_Float32_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueFloat64(
        blpapi_EventFormatter_t *formatter, blpapi_Float64_t value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueDatetime(
        blpapi_EventFormatter_t *formatter, const blpapi_Datetime_t *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueHighPrecisionDatetime(
        blpapi_EventFormatter_t *formatter,
        const blpapi_HighPrecisionDatetime_t *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueString(
        blpapi_EventFormatter_t *formatter, const char *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendValueFromName(
        blpapi_EventFormatter_t *formatter, const blpapi_Name_t *value);

BLPAPI_EXPORT
int blpapi_EventFormatter_appendElement(blpapi_EventFormatter_t *formatter);

BLPAPI_EXPORT
int blpapi_EventFormatter_getElementDefinition(
        blpapi_EventFormatter_t *formatter,
        blpapi_SchemaElementDefinition_t **definition);

#ifdef __cplusplus
}

#include <string>
#include <type_traits>

namespace BloombergLP {
namespace blpapi {

class EventFormatter {

    blpapi_EventFormatter_t *d_handle;

  private:
    EventFormatter& operator=(const EventFormatter&);
    EventFormatter(const EventFormatter&);
    EventFormatter();

  public:
    explicit EventFormatter(Event& event);
    ~EventFormatter();
    void appendMessage(const Name& messageType, const Topic& topic);
    void appendMessage(const Name& messageType,
            const Topic& topic,
            unsigned int sequenceNumber);
    void appendResponse(const Name& operationName);
    void appendRecapMessage(const Topic& topic, const CorrelationId *cid = 0);
    void appendRecapMessage(
            const Topic& topic, Message::Fragment fragmentType);
    void appendRecapMessage(const Name& messageType,
            const Topic& topic,
            Message::Fragment fragmentType = Message::FRAGMENT_NONE);
    void appendRecapMessage(const Topic& topic,
            unsigned int sequenceNumber,
            const CorrelationId *cid = 0);
    void appendRecapMessage(const Name& messageType,
            const Topic& topic,
            unsigned int sequenceNumber);
    void appendRecapMessage(const Topic& topic,
            Message::Fragment fragmentType,
            unsigned int sequenceNumber);
    void appendRecapMessage(const Name& messageType,
            const Topic& topic,
            Message::Fragment fragmentType,
            unsigned int sequenceNumber);
    void appendRecapMessage(const CorrelationId& cid,
            Message::Fragment fragmentType = Message::FRAGMENT_NONE);
    void appendRecapMessage(const Name& messageType,
            const CorrelationId& cid,
            Message::Fragment fragmentType = Message::FRAGMENT_NONE);
    void setElement(const Name& name, bool value);
    void setElement(const Name& name, char value);
    void setElement(const Name& name, Int32 value);
    void setElement(const Name& name, Int64 value);
    void setElement(const Name& name, Float32 value);
    void setElement(const Name& name, Float64 value);
    void setElement(const Name& name, const Datetime& value);
    void setElement(const Name& name, const Datetime::HighPrecision& value);
    void setElement(const Name& name, const char *value);
    void setElement(const Name& name, const std::string& value);
    void setElement(const Name& name, const Name& value);
    void setElement(const Name& name, const void *value, size_t length);
    template <typename BYTES,
            typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type
            = true>
    void setElement(const Name& name, const BYTES& value);
    void setElementNull(const Name& name);
    void pushElement(const Name& name);
    void popElement();
    void appendValue(bool value);
    void appendValue(char value);
    void appendValue(Int32 value);
    void appendValue(Int64 value);
    void appendValue(Float32 value);
    void appendValue(Float64 value);
    void appendValue(const char *value);
    void appendValue(const std::string& value);
    void appendValue(const Name& value);
    void appendValue(const Datetime& value);
    void appendValue(const Datetime::HighPrecision& value);
    void appendElement();
    void appendMessage(const char *messageType, const Topic& topic);
    void appendMessage(const char *messageType,
            const Topic& topic,
            unsigned int sequenceNumber);
    void appendResponse(const char *operationName);
    void appendRecapMessage(const char *messageType,
            const Topic& topic,
            Message::Fragment fragmentType = Message::FRAGMENT_NONE);
    void appendRecapMessage(const char *messageType,
            const Topic& topic,
            unsigned int sequenceNumber);
    void appendRecapMessage(const char *messageType,
            const Topic& topic,
            Message::Fragment fragmentType,
            unsigned int sequenceNumber);
    void appendRecapMessage(const char *messageType,
            const CorrelationId& cid,
            Message::Fragment fragmentType = Message::FRAGMENT_NONE);
    void setElement(const char *name, bool value);
    void setElement(const char *name, char value);
    void setElement(const char *name, Int32 value);
    void setElement(const char *name, Int64 value);
    void setElement(const char *name, Float32 value);
    void setElement(const char *name, Float64 value);
    void setElement(const char *name, const Datetime& value);
    void setElement(const char *name, const Datetime::HighPrecision& value);
    void setElement(const char *name, const char *value);
    void setElement(const char *name, const Name& value);
    void setElementNull(const char *name);
    void pushElement(const char *name);
};

// ============================================================================
//                      INLINE AND TEMPLATE FUNCTION IMPLEMENTATIONS
// ============================================================================

// --------------------
// class EventFormatter
// --------------------

inline EventFormatter::EventFormatter(Event& event)
{
    d_handle = blpapi_EventFormatter_create(event.impl());
}

inline EventFormatter::~EventFormatter()
{
    blpapi_EventFormatter_destroy(d_handle);
}

inline void EventFormatter::appendMessage(
        const char *messageType, const Topic& topic)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_appendMessage(
            d_handle, messageType, 0, topic.impl()));
}

inline void EventFormatter::appendMessage(
        const Name& messageType, const Topic& topic)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_appendMessage(
            d_handle, 0, messageType.impl(), topic.impl()));
}

inline void EventFormatter::appendMessage(const char *messageType,
        const Topic& topic,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL_EVENTFORMATTER_APPENDMESSAGESEQ(
            d_handle, messageType, 0, topic.impl(), sequenceNumber, 0));
}

inline void EventFormatter::appendMessage(const Name& messageType,
        const Topic& topic,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL_EVENTFORMATTER_APPENDMESSAGESEQ(
            d_handle, 0, messageType.impl(), topic.impl(), sequenceNumber, 0));
}

inline void EventFormatter::appendResponse(const char *operationName)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendResponse(d_handle, operationName, 0));
}

inline void EventFormatter::appendResponse(const Name& operationName)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_appendResponse(
            d_handle, 0, operationName.impl()));
}

inline void EventFormatter::appendRecapMessage(
        const Topic& topic, const CorrelationId *cid)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_appendRecapMessage(
            d_handle, topic.impl(), cid ? &cid->impl() : 0));
}

inline void EventFormatter::appendRecapMessage(
        const Topic& topic, Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessage)(d_handle,
            0, // 'typeString'
            0, // 'typeName'
            topic.impl(), // 'topic'
            0, // 'cid'
            static_cast<int>(fragmentType)));
}

inline void EventFormatter::appendRecapMessage(const Name& messageType,
        const Topic& topic,
        Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessage)(d_handle,
            0, // 'typeString'
            messageType.impl(), // 'typeName'
            topic.impl(), // 'topic'
            0, // 'cid'
            static_cast<int>(fragmentType)));
}

inline void EventFormatter::appendRecapMessage(const char *messageType,
        const Topic& topic,
        Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessage)(d_handle,
            messageType, // 'typeString'
            0, // 'typeName'
            topic.impl(), // 'topic'
            0, // 'cid'
            static_cast<int>(fragmentType)));
}

inline void EventFormatter::appendRecapMessage(const Topic& topic,
        unsigned int sequenceNumber,
        const CorrelationId *cid)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_EVENTFORMATTER_APPENDRECAPMESSAGESEQ(d_handle,
                    topic.impl(),
                    cid ? &cid->impl() : 0,
                    sequenceNumber,
                    0));
}

inline void EventFormatter::appendRecapMessage(const Name& messageType,
        const Topic& topic,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessageSeq)(d_handle,
            0, // 'typeString'
            messageType.impl(), // 'typeName'
            topic.impl(), // 'topic'
            static_cast<int>(Message::FRAGMENT_NONE),
            sequenceNumber));
}

inline void EventFormatter::appendRecapMessage(const char *messageType,
        const Topic& topic,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessageSeq)(d_handle,
            messageType, // 'typeString'
            0, // 'typeName'
            topic.impl(), // 'topic'
            static_cast<int>(Message::FRAGMENT_NONE),
            sequenceNumber));
}

inline void EventFormatter::appendRecapMessage(const Topic& topic,
        Message::Fragment fragmentType,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessageSeq)(d_handle,
            0, // 'typeString'
            0, // 'typeName'
            topic.impl(), // 'topic'
            static_cast<int>(fragmentType),
            sequenceNumber));
}

inline void EventFormatter::appendRecapMessage(const Name& messageType,
        const Topic& topic,
        Message::Fragment fragmentType,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessageSeq)(d_handle,
            0, // 'typeString'
            messageType.impl(), // 'typeName'
            topic.impl(), // 'topic'
            static_cast<int>(fragmentType),
            sequenceNumber));
}

inline void EventFormatter::appendRecapMessage(const char *messageType,
        const Topic& topic,
        Message::Fragment fragmentType,
        unsigned int sequenceNumber)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessageSeq)(d_handle,
            messageType, // 'typeString'
            0, // 'typeName'
            topic.impl(), // 'topic'
            static_cast<int>(fragmentType),
            sequenceNumber));
}

inline void EventFormatter::appendRecapMessage(
        const CorrelationId& cid, Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessage)(d_handle,
            0, // 'typeString'
            0, // 'typeName'
            0, // 'topic'
            &cid.impl(), // 'cid'
            static_cast<int>(fragmentType)));
}

inline void EventFormatter::appendRecapMessage(const Name& messageType,
        const CorrelationId& cid,
        Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessage)(d_handle,
            0, // 'typeString'
            messageType.impl(), // 'typeName'
            0, // 'topic'
            &cid.impl(), // 'cid'
            static_cast<int>(fragmentType)));
}

inline void EventFormatter::appendRecapMessage(const char *messageType,
        const CorrelationId& cid,
        Message::Fragment fragmentType)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendFragmentedRecapMessage)(d_handle,
            messageType, // 'typeString'
            0, // 'typeName'
            0, // 'topic'
            &cid.impl(), // 'cid'
            static_cast<int>(fragmentType)));
}

inline void EventFormatter::setElement(const char *name, bool value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueBool(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, char value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueChar(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, Int32 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueInt32(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, Int64 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueInt64(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, Float32 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueFloat32(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, Float64 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueFloat64(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, const Datetime& value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueDatetime(
            d_handle, name, 0, &value.rawValue()));
}

inline void EventFormatter::setElement(
        const char *name, const Datetime::HighPrecision& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_EventFormatter_setValueHighPrecisionDatetime)(
                    d_handle, name, 0, &value));
}

inline void EventFormatter::setElement(const char *name, const char *value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_setValueString(d_handle, name, 0, value));
}

inline void EventFormatter::setElement(const char *name, const Name& value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueFromName(
            d_handle, name, 0, value.impl()));
}

inline void EventFormatter::setElementNull(const char *name)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_EVENTFORMATTER_SETVALUENULL(d_handle, name, 0));
}

inline void EventFormatter::setElement(const Name& name, bool value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueBool(
            d_handle, 0, name.impl(), value));
}

inline void EventFormatter::setElement(const Name& name, char value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueChar(
            d_handle, 0, name.impl(), value));
}

inline void EventFormatter::setElement(const Name& name, Int32 value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueInt32(
            d_handle, 0, name.impl(), value));
}

inline void EventFormatter::setElement(const Name& name, Int64 value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueInt64(
            d_handle, 0, name.impl(), value));
}

inline void EventFormatter::setElement(const Name& name, Float32 value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueFloat32(
            d_handle, 0, name.impl(), value));
}
inline void EventFormatter::setElement(const Name& name, Float64 value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueFloat64(
            d_handle, 0, name.impl(), value));
}

inline void EventFormatter::setElement(const Name& name, const Datetime& value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueDatetime(
            d_handle, 0, name.impl(), &value.rawValue()));
}

inline void EventFormatter::setElement(
        const Name& name, const Datetime::HighPrecision& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_EventFormatter_setValueHighPrecisionDatetime)(
                    d_handle, 0, name.impl(), &value));
}

inline void EventFormatter::setElement(const Name& name, const char *value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueString(
            d_handle, 0, name.impl(), value));
}

inline void EventFormatter::setElement(
        const Name& name, const std::string& value)
{
    setElement(name, value.c_str());
}

inline void EventFormatter::setElement(const Name& name, const Name& value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_setValueFromName(
            d_handle, 0, name.impl(), value.impl()));
}

inline void EventFormatter::setElement(
        const Name& name, const void *value, size_t length)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_EventFormatter_setValueBytes)(d_handle,
                    0,
                    name.impl(),
                    reinterpret_cast<const char *>(value),
                    length));
}

template <typename BYTES,
        typename std::enable_if<IsByteSequence<BYTES>::value, bool>::type>
inline void EventFormatter::setElement(const Name& name, const BYTES& value)
{
    setElement(name, value.data(), value.size());
}

inline void EventFormatter::setElementNull(const Name& name)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_EVENTFORMATTER_SETVALUENULL(d_handle, 0, name.impl()));
}

inline void EventFormatter::pushElement(const char *name)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_pushElement(d_handle, name, 0));
}

inline void EventFormatter::pushElement(const Name& name)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_pushElement(d_handle, 0, name.impl()));
}

inline void EventFormatter::popElement()
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_popElement(d_handle));
}

inline void EventFormatter::appendValue(bool value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueBool(d_handle, value));
}

inline void EventFormatter::appendValue(char value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueChar(d_handle, value));
}

inline void EventFormatter::appendValue(Int32 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueInt32(d_handle, value));
}

inline void EventFormatter::appendValue(Int64 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueInt64(d_handle, value));
}

inline void EventFormatter::appendValue(Float32 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueFloat32(d_handle, value));
}

inline void EventFormatter::appendValue(Float64 value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueFloat64(d_handle, value));
}

inline void EventFormatter::appendValue(const Datetime& value)
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_appendValueDatetime(
            d_handle, &value.rawValue()));
}

inline void EventFormatter::appendValue(const Datetime::HighPrecision& value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_EventFormatter_appendValueHighPrecisionDatetime)(
            d_handle, &value));
}

inline void EventFormatter::appendValue(const char *value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueString(d_handle, value));
}

inline void EventFormatter::appendValue(const std::string& value)
{
    appendValue(value.c_str());
}

inline void EventFormatter::appendValue(const Name& value)
{
    ExceptionUtil::throwOnError(
            blpapi_EventFormatter_appendValueFromName(d_handle, value.impl()));
}

inline void EventFormatter::appendElement()
{
    ExceptionUtil::throwOnError(blpapi_EventFormatter_appendElement(d_handle));
}

} // close namespace blpapi
} // close namespace BloombergLP

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_EVENTFORMATTER