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_deprecate.h>
#include <blpapi_element.h>
#include <blpapi_name.h>
#include <blpapi_service.h>
#include <blpapi_streamproxy.h>
#include <blpapi_timepoint.h>
 
struct blpapi_Message;
#ifdef __cplusplus
extern "C" {
#endif

typedef struct blpapi_Message blpapi_Message_t;


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;
 
    BLPAPI_DEPRECATE_MESSAGE_TOPIC_NAME 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;
 
    BLPAPI_DEPRECATE_STRING_NAME bool hasElement(
            const char *name, bool excludeNullElements = false) const;
 
    size_t numElements() const;
 
    const Element getElement(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME const Element getElement(
            const char *name) const;
 
    bool getElementAsBool(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME bool getElementAsBool(const char *name) const;
 
    char getElementAsChar(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME char getElementAsChar(const char *name) const;
 
    Int32 getElementAsInt32(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME Int32 getElementAsInt32(
            const char *name) const;
 
    Int64 getElementAsInt64(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME Int64 getElementAsInt64(
            const char *name) const;
 
    Float32 getElementAsFloat32(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME Float32 getElementAsFloat32(
            const char *name) const;
 
    Float64 getElementAsFloat64(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME Float64 getElementAsFloat64(
            const char *name) const;
 
    Datetime getElementAsDatetime(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME Datetime getElementAsDatetime(
            const char *name) const;
 
    const char *getElementAsString(const Name& name) const;
 
    BLPAPI_DEPRECATE_STRING_NAME const char *getElementAsString(
            const char *name) const;
 
    Bytes getElementAsBytes(const Name& name) const;
 
    const char *getRequestId() const;
 
    const Element asElement() const;
 
    std::string toJson() const;
 
    BLPAPI_DEPRECATE_STRING_NAME 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);
 
namespace util {

 
constexpr const char *to_string(Message::Fragment fragment);
 
constexpr const char *to_string(Message::RecapType::Type recapType);

 
} // close namespace util
 
// ============================================================================
//                      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 std::string Message::toJson() const { return d_elements.toJson(); }
 
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; }
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(Message::Fragment fragment)
{
    switch (fragment) {
    case Message::FRAGMENT_NONE:
        return "FRAGMENT_NONE";
    case Message::FRAGMENT_START:
        return "FRAGMENT_START";
    case Message::FRAGMENT_INTERMEDIATE:
        return "FRAGMENT_INTERMEDIATE";
    case Message::FRAGMENT_END:
        return "FRAGMENT_END";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(Message::RecapType::Type recapType)
{
    switch (recapType) {
    case Message::RecapType::e_none:
        return "e_none";
    case Message::RecapType::e_solicited:
        return "e_solicited";
    case Message::RecapType::e_unsolicited:
        return "e_unsolicited";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_MESSAGE