blpapi_messageformatter.h

Go to the documentation of this file.

/* Copyright 2019. 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_MESSAGEFORMATTER
#define INCLUDED_BLPAPI_MESSAGEFORMATTER

#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
int blpapi_MessageFormatter_setValueBool(blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        blpapi_Bool_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueChar(blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        char value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueInt32(blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        blpapi_Int32_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueInt64(blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        blpapi_Int64_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueFloat32(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        blpapi_Float32_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueFloat64(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        blpapi_Float64_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueDatetime(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        const blpapi_Datetime_t *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueHighPrecisionDatetime(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        const blpapi_HighPrecisionDatetime_t *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueString(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        const char *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueFromName(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        const blpapi_Name_t *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueBytes(blpapi_MessageFormatter_t *formatter,
        const blpapi_Name_t *typeName,
        const char *value,
        size_t length);

BLPAPI_EXPORT
int blpapi_MessageFormatter_setValueNull(
        blpapi_MessageFormatter_t *formatter, const blpapi_Name_t *typeName);

BLPAPI_EXPORT
int blpapi_MessageFormatter_pushElement(
        blpapi_MessageFormatter_t *formatter, const blpapi_Name_t *typeName);

BLPAPI_EXPORT
int blpapi_MessageFormatter_popElement(blpapi_MessageFormatter_t *formatter);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueBool(
        blpapi_MessageFormatter_t *formatter, blpapi_Bool_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueChar(
        blpapi_MessageFormatter_t *formatter, char value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueInt32(
        blpapi_MessageFormatter_t *formatter, blpapi_Int32_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueInt64(
        blpapi_MessageFormatter_t *formatter, blpapi_Int64_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueFloat32(
        blpapi_MessageFormatter_t *formatter, blpapi_Float32_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueFloat64(
        blpapi_MessageFormatter_t *formatter, blpapi_Float64_t value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueDatetime(
        blpapi_MessageFormatter_t *formatter, const blpapi_Datetime_t *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueHighPrecisionDatetime(
        blpapi_MessageFormatter_t *formatter,
        const blpapi_HighPrecisionDatetime_t *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueString(
        blpapi_MessageFormatter_t *formatter, const char *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendValueFromName(
        blpapi_MessageFormatter_t *formatter, const blpapi_Name_t *value);

BLPAPI_EXPORT
int blpapi_MessageFormatter_appendElement(
        blpapi_MessageFormatter_t *formatter);

BLPAPI_EXPORT
int blpapi_MessageFormatter_FormatMessageJson(
        blpapi_MessageFormatter_t *formatter, const char *message);

BLPAPI_EXPORT
int blpapi_MessageFormatter_FormatMessageXml(
        blpapi_MessageFormatter_t *formatter, const char *message);

BLPAPI_EXPORT
int blpapi_MessageFormatter_copy(blpapi_MessageFormatter_t **formatter,
        const blpapi_MessageFormatter_t *original);

BLPAPI_EXPORT
int blpapi_MessageFormatter_assign(
        blpapi_MessageFormatter_t **lhs, const blpapi_MessageFormatter_t *rhs);

BLPAPI_EXPORT
int blpapi_MessageFormatter_destroy(blpapi_MessageFormatter_t *formatter);

BLPAPI_EXPORT
int blpapi_MessageFormatter_getElementDefinition(
        blpapi_MessageFormatter_t *formatter,
        blpapi_SchemaElementDefinition_t **definition);

#ifdef __cplusplus
} // extern "C"

#include <string>
#include <type_traits>

namespace BloombergLP {
namespace blpapi {
namespace test {

class MessageFormatter {

  private:
    blpapi_MessageFormatter_t *d_handle;

  public:
    // CREATORS
    explicit MessageFormatter(blpapi_MessageFormatter_t *handle);
    MessageFormatter(const MessageFormatter& original);
    ~MessageFormatter();
    // MANIPULATORS
    MessageFormatter& operator=(const MessageFormatter& rhs);
    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 Datetime& value);
    void appendValue(const Datetime::HighPrecision& value);
    void appendValue(const char *value);
    void appendValue(const std::string& value);
    void appendValue(const Name& value);
    void appendElement();
    void formatMessageJson(const char *message);
    void formatMessageXml(const char *message);
    // ACCESSORS
    blpapi_MessageFormatter_t *impl() const;
};

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

// ----------------------
// class MessageFormatter
// ----------------------

inline MessageFormatter::MessageFormatter(blpapi_MessageFormatter_t *handle)
    : d_handle(handle)
{
}

inline MessageFormatter::~MessageFormatter()
{
    if (d_handle) {
        BLPAPI_CALL_UNCHECKED(blpapi_MessageFormatter_destroy)(d_handle);
    }
}

inline MessageFormatter::MessageFormatter(const MessageFormatter& original)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_MessageFormatter_copy)(
            &d_handle, original.impl()));
}

inline MessageFormatter& MessageFormatter::operator=(
        const MessageFormatter& rhs)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_MessageFormatter_assign)(
            &d_handle, rhs.impl()));
    return *this;
}

inline void MessageFormatter::setElement(const Name& name, bool value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueBool)(
                    d_handle, name.impl(), value));
}

inline void MessageFormatter::setElement(const Name& name, char value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueChar)(
                    d_handle, name.impl(), value));
}

inline void MessageFormatter::setElement(const Name& name, Int32 value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueInt32)(
                    d_handle, name.impl(), value));
}

inline void MessageFormatter::setElement(const Name& name, Int64 value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueInt64)(
                    d_handle, name.impl(), value));
}

inline void MessageFormatter::setElement(const Name& name, Float32 value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueFloat32)(
                    d_handle, name.impl(), value));
}

inline void MessageFormatter::setElement(const Name& name, Float64 value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueFloat64)(
                    d_handle, name.impl(), value));
}

inline void MessageFormatter::setElement(
        const Name& name, const Datetime& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueDatetime)(
                    d_handle, name.impl(), &value.rawValue()));
}

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

inline void MessageFormatter::setElement(const Name& name, const char *value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueString)(
                    d_handle, name.impl(), value));
}

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

inline void MessageFormatter::setElement(const Name& name, const Name& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_setValueFromName)(
                    d_handle, name.impl(), value.impl()));
}

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

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

inline void MessageFormatter::setElementNull(const Name& name)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_setValueNull)(d_handle, name.impl()));
}

inline void MessageFormatter::pushElement(const Name& name)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_pushElement)(d_handle, name.impl()));
}

inline void MessageFormatter::popElement()
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_popElement)(d_handle));
}

inline void MessageFormatter::appendValue(bool value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueBool)(d_handle, value));
}

inline void MessageFormatter::appendValue(char value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueChar)(d_handle, value));
}

inline void MessageFormatter::appendValue(Int32 value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueInt32)(d_handle, value));
}

inline void MessageFormatter::appendValue(Int64 value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueInt64)(d_handle, value));
}

inline void MessageFormatter::appendValue(Float32 value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueFloat32)(d_handle, value));
}

inline void MessageFormatter::appendValue(Float64 value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueFloat64)(d_handle, value));
}

inline void MessageFormatter::appendValue(const Datetime& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_appendValueDatetime)(
                    d_handle, &value.rawValue()));
}

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

inline void MessageFormatter::appendValue(const char *value)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_appendValueString)(d_handle, value));
}

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

inline void MessageFormatter::appendValue(const Name& value)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_appendValueFromName)(
                    d_handle, value.impl()));
}

inline void MessageFormatter::appendElement()
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_MessageFormatter_appendElement)(d_handle));
}

inline blpapi_MessageFormatter_t *MessageFormatter::impl() const
{
    return d_handle;
}

inline void MessageFormatter::formatMessageJson(const char *message)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_FormatMessageJson)(d_handle, message));
}

inline void MessageFormatter::formatMessageXml(const char *message)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_MessageFormatter_FormatMessageXml)(d_handle, message));
}

} // close namespace test

// *Deprecated*
// Following typedef is provided for backwards compatibility. It will be
// removed in a future release.
typedef test::MessageFormatter MessageFormatter;

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

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_MESSAGEFORMATTER