blpapi_message.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_MESSAGE
#define INCLUDED_BLPAPI_MESSAGE

#include <blpapi_call.h>
#include <blpapi_correlationid.h>
#include <blpapi_defs.h>
#include <blpapi_element.h>
#include <blpapi_name.h>
#include <blpapi_service.h>
#include <blpapi_streamproxy.h>
#include <blpapi_timepoint.h>

struct blpapi_Message;
typedef struct blpapi_Message blpapi_Message_t;

#ifdef __cplusplus
extern "C" {
#endif

BLPAPI_EXPORT
blpapi_Name_t *blpapi_Message_messageType(const blpapi_Message_t *message);

BLPAPI_EXPORT
const char *blpapi_Message_typeString(const blpapi_Message_t *message);

BLPAPI_EXPORT
const char *blpapi_Message_topicName(const blpapi_Message_t *message);

BLPAPI_EXPORT
blpapi_Service_t *blpapi_Message_service(const blpapi_Message_t *message);

BLPAPI_EXPORT
int blpapi_Message_numCorrelationIds(const blpapi_Message_t *message);

BLPAPI_EXPORT
blpapi_CorrelationId_t blpapi_Message_correlationId(
        const blpapi_Message_t *message, size_t index);

BLPAPI_EXPORT
int blpapi_Message_getRequestId(
        const blpapi_Message_t *message, const char **requestId);

BLPAPI_EXPORT
blpapi_Element_t *blpapi_Message_elements(const blpapi_Message_t *message);

BLPAPI_EXPORT
const char *blpapi_Message_privateData(
        const blpapi_Message_t *message, size_t *size);

BLPAPI_EXPORT
int blpapi_Message_fragmentType(const blpapi_Message_t *message);

BLPAPI_EXPORT
int blpapi_Message_recapType(const blpapi_Message_t *message);

BLPAPI_EXPORT
int blpapi_Message_print(const blpapi_Message_t *message,
        blpapi_StreamWriter_t streamWriter,
        void *stream,
        int indentLevel,
        int spacesPerLevel);

BLPAPI_EXPORT
int blpapi_Message_addRef(const blpapi_Message_t *message);

BLPAPI_EXPORT
int blpapi_Message_release(const blpapi_Message_t *message);

BLPAPI_EXPORT
int blpapi_Message_timeReceived(
        const blpapi_Message_t *message, blpapi_TimePoint_t *timeReceived);

#ifdef __cplusplus
}

namespace BloombergLP {
namespace blpapi {

class Message {

    blpapi_Message_t *d_handle;
    Element d_elements;
    bool d_isCloned;

  public:
    enum Fragment {

        FRAGMENT_NONE = BLPAPI_MESSAGE_FRAGMENT_NONE,
        FRAGMENT_START = BLPAPI_MESSAGE_FRAGMENT_START,
        FRAGMENT_INTERMEDIATE = BLPAPI_MESSAGE_FRAGMENT_INTERMEDIATE,
        FRAGMENT_END = BLPAPI_MESSAGE_FRAGMENT_END
    };

    struct RecapType {
        enum Type {
            e_none = BLPAPI_MESSAGE_RECAPTYPE_NONE,
            e_solicited = BLPAPI_MESSAGE_RECAPTYPE_SOLICITED,
            e_unsolicited = BLPAPI_MESSAGE_RECAPTYPE_UNSOLICITED
        };
    };

  public:
    // CREATORS

    explicit Message(blpapi_Message_t *handle, bool clonable = false);

    Message(const Message& original);
    ~Message();
    // MANIUPLATORS
    Message& operator=(const Message& rhs);
    // ACCESSORS
    Name messageType() const;
    const char *topicName() const;
    Service service() const;
    int numCorrelationIds() const;
    CorrelationId correlationId(size_t index = 0) const;
    RecapType::Type recapType() const;
    bool hasElement(const Name& name, bool excludeNullElements = false) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] bool
    hasElement(const char *name, bool excludeNullElements = false) const;
    size_t numElements() const;
    const Element getElement(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const "
                 "char*")]] const Element
    getElement(const char *name) const;
    bool getElementAsBool(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] bool
    getElementAsBool(const char *name) const;
    char getElementAsChar(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] char
    getElementAsChar(const char *name) const;
    Int32 getElementAsInt32(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] Int32
    getElementAsInt32(const char *name) const;
    Int64 getElementAsInt64(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const char*")]] Int64
    getElementAsInt64(const char *name) const;
    Float32 getElementAsFloat32(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Float32
    getElementAsFloat32(const char *name) const;
    Float64 getElementAsFloat64(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Float64
    getElementAsFloat64(const char *name) const;
    Datetime getElementAsDatetime(const Name& name) const;
    [[deprecated(
            "Use the form that takes Name instead of const char*")]] Datetime
    getElementAsDatetime(const char *name) const;
    const char *getElementAsString(const Name& name) const;
    [[deprecated("Use the form that takes Name instead of const "
                 "char*")]] const char *
    getElementAsString(const char *name) const;
    Bytes getElementAsBytes(const Name& name) const;
    const char *getRequestId() const;
    const Element asElement() const;
    [[deprecated("This method is no longer supported")]] const char *
    getPrivateData(size_t *size) const;
    Fragment fragmentType() const;
    int timeReceived(TimePoint *timestamp) const;
    std::ostream& print(
            std::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
    const blpapi_Message_t *impl() const;
    blpapi_Message_t *impl();
};

// FREE OPERATORS
std::ostream& operator<<(std::ostream& stream, const Message& message);
// ============================================================================
//                      INLINE AND TEMPLATE FUNCTION IMPLEMENTATIONS
// ============================================================================

// -------------
// class Message
// -------------
// CREATORS
inline Message::Message(blpapi_Message_t *handle, bool clonable)
    : d_handle(handle)
    , d_isCloned(clonable)
{
    if (handle) {
        d_elements = Element(blpapi_Message_elements(handle));
    }
}

inline Message::Message(const Message& original)
    : d_handle(original.d_handle)
    , d_elements(original.d_elements)
    , d_isCloned(true)
{
    if (d_handle) {
        BLPAPI_CALL_MESSAGE_ADDREF(d_handle);
    }
}

inline Message::~Message()
{
    if (d_isCloned && d_handle) {
        BLPAPI_CALL_MESSAGE_RELEASE(d_handle);
    }
}
// MANIPULATORS
inline Message& Message::operator=(const Message& rhs)
{

    if (this == &rhs) {
        return *this;
    }

    if (d_isCloned && (d_handle == rhs.d_handle)) {
        return *this;
    }

    if (d_isCloned && d_handle) {
        BLPAPI_CALL_MESSAGE_RELEASE(d_handle);
    }
    d_handle = rhs.d_handle;
    d_elements = rhs.d_elements;
    d_isCloned = true;

    if (d_handle) {
        BLPAPI_CALL_MESSAGE_ADDREF(d_handle);
    }

    return *this;
}

// ACCESSORS
inline Name Message::messageType() const
{
    return Name(blpapi_Message_messageType(d_handle));
}

inline const char *Message::topicName() const
{
    return blpapi_Message_topicName(d_handle);
}

inline Service Message::service() const
{
    return Service(blpapi_Message_service(d_handle));
}

inline int Message::numCorrelationIds() const
{
    return blpapi_Message_numCorrelationIds(d_handle);
}

inline CorrelationId Message::correlationId(size_t index) const
{
    if (index >= (size_t)numCorrelationIds())
        throw IndexOutOfRangeException("index >= numCorrelationIds");
    return CorrelationId(blpapi_Message_correlationId(d_handle, index));
}

inline bool Message::hasElement(
        const char *name, bool excludeNullElements) const
{
    return d_elements.hasElement(Name(name), excludeNullElements);
}

inline bool Message::hasElement(
        const Name& name, bool excludeNullElements) const
{
    return d_elements.hasElement(name, excludeNullElements);
}

inline size_t Message::numElements() const { return d_elements.numElements(); }

inline const Element Message::getElement(const Name& name) const
{
    return d_elements.getElement(name);
}

inline const Element Message::getElement(const char *nameString) const
{
    return d_elements.getElement(Name(nameString));
}

inline bool Message::getElementAsBool(const Name& name) const
{
    return d_elements.getElementAsBool(name);
}

inline bool Message::getElementAsBool(const char *name) const
{
    return d_elements.getElementAsBool(Name(name));
}

inline char Message::getElementAsChar(const Name& name) const
{
    return d_elements.getElementAsChar(name);
}

inline char Message::getElementAsChar(const char *name) const
{
    return d_elements.getElementAsChar(Name(name));
}

inline Int32 Message::getElementAsInt32(const Name& name) const
{
    return d_elements.getElementAsInt32(name);
}

inline Int32 Message::getElementAsInt32(const char *name) const
{
    return d_elements.getElementAsInt32(Name(name));
}

inline Int64 Message::getElementAsInt64(const Name& name) const
{
    return d_elements.getElementAsInt64(name);
}

inline Int64 Message::getElementAsInt64(const char *name) const
{
    return d_elements.getElementAsInt64(Name(name));
}

inline Float32 Message::getElementAsFloat32(const Name& name) const
{
    return d_elements.getElementAsFloat32(name);
}

inline Float32 Message::getElementAsFloat32(const char *name) const
{
    return d_elements.getElementAsFloat32(Name(name));
}

inline Float64 Message::getElementAsFloat64(const Name& name) const
{
    return d_elements.getElementAsFloat64(name);
}

inline Float64 Message::getElementAsFloat64(const char *name) const
{
    return d_elements.getElementAsFloat64(Name(name));
}

inline Datetime Message::getElementAsDatetime(const Name& name) const
{
    return d_elements.getElementAsDatetime(name);
}

inline Datetime Message::getElementAsDatetime(const char *name) const
{
    return d_elements.getElementAsDatetime(Name(name));
}

inline const char *Message::getElementAsString(const Name& name) const
{
    return d_elements.getElementAsString(name);
}

inline const char *Message::getElementAsString(const char *name) const
{
    return d_elements.getElementAsString(Name(name));
}

inline Bytes Message::getElementAsBytes(const Name& name) const
{
    return d_elements.getElementAsBytes(name);
}

inline const char *Message::getRequestId() const
{
    const char *requestId = 0;
    BLPAPI_CALL(blpapi_Message_getRequestId)(d_handle, &requestId);
    return requestId;
}

inline const Element Message::asElement() const { return d_elements; }

inline const char *Message::getPrivateData(size_t *size) const
{
    return blpapi_Message_privateData(d_handle, size);
}

inline Message::Fragment Message::fragmentType() const
{
    return (Message::Fragment)BLPAPI_CALL_MESSAGE_FRAGMENTTYPE(d_handle);
}

inline Message::RecapType::Type Message::recapType() const
{
    return static_cast<Message::RecapType::Type>(
            BLPAPI_CALL(blpapi_Message_recapType)(d_handle));
}

inline int Message::timeReceived(TimePoint *timestamp) const
{
    return BLPAPI_CALL_MESSAGE_TIMERECEIVED(d_handle, timestamp);
}

inline std::ostream& Message::print(
        std::ostream& stream, int level, int spacesPerLevel) const
{
    if (BLPAPI_CALL_AVAILABLE(blpapi_Message_print)) {
        BLPAPI_CALL(blpapi_Message_print)
        (d_handle,
                StreamProxyOstream::writeToStream,
                &stream,
                level,
                spacesPerLevel);
        return stream;
    } else {
        return d_elements.print(stream, level, spacesPerLevel);
    }
}

inline std::ostream& operator<<(std::ostream& stream, const Message& message)
{
    return message.print(stream, 0, -1);
}

inline const blpapi_Message_t *Message::impl() const { return d_handle; }

inline blpapi_Message_t *Message::impl() { return d_handle; }

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

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_MESSAGE