blpapi_event.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_EVENT
#define INCLUDED_BLPAPI_EVENT

 
#include <blpapi_call.h>
#include <blpapi_defs.h>
#include <blpapi_message.h>
 
#ifdef __cplusplus
extern "C" {
#endif



BLPAPI_EXPORT
int blpapi_Event_eventType(const blpapi_Event_t *event);

BLPAPI_EXPORT
int blpapi_Event_addRef(const blpapi_Event_t *event);

BLPAPI_EXPORT
int blpapi_Event_release(const blpapi_Event_t *event);

BLPAPI_EXPORT
blpapi_EventQueue_t *blpapi_EventQueue_create(void);

BLPAPI_EXPORT
int blpapi_EventQueue_destroy(blpapi_EventQueue_t *eventQueue);

BLPAPI_EXPORT
blpapi_Event_t *blpapi_EventQueue_nextEvent(
        blpapi_EventQueue_t *eventQueue, int timeout);

BLPAPI_EXPORT
int blpapi_EventQueue_purge(blpapi_EventQueue_t *eventQueue);

BLPAPI_EXPORT
int blpapi_EventQueue_tryNextEvent(
        blpapi_EventQueue_t *eventQueue, blpapi_Event_t **eventPointer);

BLPAPI_EXPORT
blpapi_MessageIterator_t *blpapi_MessageIterator_create(
        const blpapi_Event_t *event);

BLPAPI_EXPORT
void blpapi_MessageIterator_destroy(blpapi_MessageIterator_t *iterator);

BLPAPI_EXPORT
int blpapi_MessageIterator_next(
        blpapi_MessageIterator_t *iterator, blpapi_Message_t **result);

BLPAPI_EXPORT
int blpapi_MessageIterator_addRef(const blpapi_MessageIterator_t *iterator);

 
#ifdef __cplusplus
}
 
#include <cassert>
#include <utility>
 
namespace BloombergLP {
namespace blpapi {

class Event {
 
    blpapi_Event_t *d_impl_p;
 
  public:
    enum EventType {
        ADMIN = BLPAPI_EVENTTYPE_ADMIN,
        SESSION_STATUS = BLPAPI_EVENTTYPE_SESSION_STATUS,
        SUBSCRIPTION_STATUS = BLPAPI_EVENTTYPE_SUBSCRIPTION_STATUS,
        REQUEST_STATUS = BLPAPI_EVENTTYPE_REQUEST_STATUS,
        RESPONSE = BLPAPI_EVENTTYPE_RESPONSE,
        PARTIAL_RESPONSE = BLPAPI_EVENTTYPE_PARTIAL_RESPONSE,
        SUBSCRIPTION_DATA = BLPAPI_EVENTTYPE_SUBSCRIPTION_DATA,
        SERVICE_STATUS = BLPAPI_EVENTTYPE_SERVICE_STATUS,
        TIMEOUT = BLPAPI_EVENTTYPE_TIMEOUT,
        AUTHORIZATION_STATUS = BLPAPI_EVENTTYPE_AUTHORIZATION_STATUS,
        RESOLUTION_STATUS = BLPAPI_EVENTTYPE_RESOLUTION_STATUS,
        TOPIC_STATUS = BLPAPI_EVENTTYPE_TOPIC_STATUS,
        TOKEN_STATUS = BLPAPI_EVENTTYPE_TOKEN_STATUS,
        REQUEST = BLPAPI_EVENTTYPE_REQUEST,
        UNKNOWN = -1
    };

    class iterator {
        // DATA
        blpapi_MessageIterator_t *d_impl_p;
        Message d_currentMessage;
 
      public:
        // TYPES
        using difference_type = std::ptrdiff_t;
        using value_type = Message;
        using pointer = Message *;
        using reference = Message&;
        using iterator_category = std::input_iterator_tag;
 
        // CREATORS
        iterator();
 
        explicit iterator(const Event& event);
 
        iterator(const iterator& original);
 
        ~iterator();
 
        // MANIPULATORS
        iterator& operator=(const iterator& original);
 
        iterator& operator++();
 
        iterator operator++(int);
 
        void swap(iterator& other);
 
        // ACCESSORS
        const Message& operator*() const noexcept;
        const Message *operator->() const noexcept;
 
        // FRIENDS
        friend bool operator==(const iterator& lhs, const iterator& rhs);
    };
 
    Event();
 
    Event(blpapi_Event_t *handle);
 
    Event(const Event& original);
 
    ~Event();
 
    Event& operator=(const Event& rhs);
 
    EventType eventType() const;
 
    bool isValid() const;

    blpapi_Event_t *impl() const;
 
    iterator begin() const;
    iterator end() const;
};
 
// FREE OPERATORS
bool operator==(const Event::iterator& lhs, const Event::iterator& rhs);
 
bool operator!=(const Event::iterator& lhs, const Event::iterator& rhs);
 
namespace util {

 
constexpr const char *to_string(Event::EventType eventType);

 
} // close namespace util

class EventQueue {
 
    blpapi_EventQueue_t *d_handle_p;
 
  public:
    EventQueue();
 
    EventQueue(const EventQueue&) = delete;
    EventQueue& operator=(const EventQueue&) = delete;
 
    virtual ~EventQueue();
 
    virtual Event nextEvent(int timeout = 0);
 
    virtual int tryNextEvent(Event *event);
 
    virtual void purge();

    blpapi_EventQueue_t *handle() const;
};

class MessageIterator {
 
    blpapi_MessageIterator_t *d_impl_p;
    blpapi_Message_t *d_current_p;
 
  public:
    MessageIterator(const MessageIterator&) = delete;
    MessageIterator& operator=(const MessageIterator&) = delete;
 
    explicit MessageIterator(const Event& event);
 
    ~MessageIterator();
 
    bool next();
 
    bool isValid() const;
 
    Message message(bool createClonable = false) const;
};
 
void swap(Event::iterator& lhs, Event::iterator& rhs);

 
//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================
 
// -----------
// class Event
// -----------
 
inline Event::Event()
    : d_impl_p(0)
{
}
 
inline Event::Event(blpapi_Event_t *handle)
    : d_impl_p(handle)
{
}
 
inline Event::Event(const Event& original)
    : d_impl_p(original.d_impl_p)
{
    if (d_impl_p) {
        blpapi_Event_addRef(d_impl_p);
    }
}
 
inline Event::~Event()
{
    if (d_impl_p) {
        blpapi_Event_release(d_impl_p);
    }
}
 
inline Event& Event::operator=(const Event& rhs)
{
    using std::swap;
 
    Event tmp(rhs);
    swap(tmp.d_impl_p, d_impl_p);
 
    return *this;
}
 
inline Event::EventType Event::eventType() const
{
    return (EventType)blpapi_Event_eventType(d_impl_p);
}
 
inline bool Event::isValid() const { return d_impl_p ? true : false; }

inline blpapi_Event_t *Event::impl() const { return d_impl_p; }
 
inline Event::iterator Event::begin() const { return iterator(*this); }
 
inline Event::iterator Event::end() const { return iterator(); }
 
// ----------------
// class EventQueue
// ----------------
 
inline EventQueue::EventQueue() { d_handle_p = blpapi_EventQueue_create(); }
 
inline EventQueue::~EventQueue() { blpapi_EventQueue_destroy(d_handle_p); }
 
inline Event EventQueue::nextEvent(int timeout)
{
    return Event(blpapi_EventQueue_nextEvent(d_handle_p, timeout));
}
 
inline int EventQueue::tryNextEvent(Event *event)
{
    assert(event);
 
    blpapi_Event_t *impl = 0;
    int ret = blpapi_EventQueue_tryNextEvent(d_handle_p, &impl);
    if (0 == ret) {
        *event = Event(impl);
    }
    return ret;
}
 
inline void EventQueue::purge() { blpapi_EventQueue_purge(d_handle_p); }

inline blpapi_EventQueue_t *EventQueue::handle() const { return d_handle_p; }
 
// ---------------------
// class MessageIterator
// ---------------------
 
inline MessageIterator::MessageIterator(const Event& event)
    : d_impl_p(nullptr)
    , d_current_p(nullptr)
{
    d_impl_p = blpapi_MessageIterator_create(event.impl());
}
 
inline MessageIterator::~MessageIterator()
{
    blpapi_MessageIterator_destroy(d_impl_p);
}
 
inline bool MessageIterator::next()
{
    return !blpapi_MessageIterator_next(d_impl_p, &d_current_p);
}
 
inline bool MessageIterator::isValid() const
{
    return d_current_p ? true : false;
}
 
inline Message MessageIterator::message(bool createClonable) const
{
    if (createClonable) {
        BLPAPI_CALL_MESSAGE_ADDREF(d_current_p);
    }
    return Message(d_current_p, createClonable);
}
 
// --------------------------
// class Event::iterator
// --------------------------
 
inline Event::iterator::iterator()
    : d_impl_p(nullptr)
    , d_currentMessage(nullptr)
{
}
 
inline Event::iterator::iterator(const Event& event)
    : iterator()
{
    if (event.impl()) {
        d_impl_p = blpapi_MessageIterator_create(event.impl());
        ++(*this);
    }
}
 
inline Event::iterator::iterator(const iterator& original)
    : d_impl_p(original.d_impl_p)
    , d_currentMessage(original.d_currentMessage)
{
    if (d_impl_p) {
        BLPAPI_CALL(blpapi_MessageIterator_addRef)(d_impl_p);
    }
}
 
inline Event::iterator::~iterator()
{
    blpapi_MessageIterator_destroy(d_impl_p);
}
 
inline Event::iterator& Event::iterator::operator=(const iterator& original)
{
    auto copy(original);
    copy.swap(*this);
    return *this;
}
 
inline const Message& Event::iterator::operator*() const noexcept
{
    return d_currentMessage;
}
 
inline const Message *Event::iterator::operator->() const noexcept
{
    return &d_currentMessage;
}
 
inline Event::iterator& Event::iterator::operator++()
{
    d_currentMessage = Message(nullptr);
 
    blpapi_Message_t *nextMessage = nullptr;
    blpapi_MessageIterator_next(d_impl_p, &nextMessage);
    d_currentMessage = Message(nextMessage);
 
    return *this;
}
 
inline Event::iterator Event::iterator::operator++(int)
{
    auto copy = *this;
    ++(*this);
    return copy;
}
 
inline void Event::iterator::swap(iterator& other)
{
    using std::swap;
    swap(d_impl_p, other.d_impl_p);
    swap(d_currentMessage, other.d_currentMessage);
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(Event::EventType eventType)
{
    switch (eventType) {
    case Event::ADMIN:
        return "ADMIN";
    case Event::SESSION_STATUS:
        return "SESSION_STATUS";
    case Event::SUBSCRIPTION_STATUS:
        return "SUBSCRIPTION_STATUS";
    case Event::REQUEST_STATUS:
        return "REQUEST_STATUS";
    case Event::RESPONSE:
        return "RESPONSE";
    case Event::PARTIAL_RESPONSE:
        return "PARTIAL_RESPONSE";
    case Event::SUBSCRIPTION_DATA:
        return "SUBSCRIPTION_DATA";
    case Event::SERVICE_STATUS:
        return "SERVICE_STATUS";
    case Event::TIMEOUT:
        return "TIMEOUT";
    case Event::AUTHORIZATION_STATUS:
        return "AUTHORIZATION_STATUS";
    case Event::RESOLUTION_STATUS:
        return "RESOLUTION_STATUS";
    case Event::TOPIC_STATUS:
        return "TOPIC_STATUS";
    case Event::TOKEN_STATUS:
        return "TOKEN_STATUS";
    case Event::REQUEST:
        return "REQUEST";
    case Event::UNKNOWN:
        return "UNKNOWN";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
 
inline bool blpapi::operator==(
        Event::iterator const& lhs, Event::iterator const& rhs)
{
    if (&lhs == &rhs) {
        return true;
    }
 
    if (lhs.d_impl_p == rhs.d_impl_p
            && lhs.d_currentMessage.impl() == rhs.d_currentMessage.impl()) {
        return true;
    }
 
    const bool lend = !lhs.d_impl_p || !lhs.d_currentMessage.impl();
    const bool rend = !rhs.d_impl_p || !rhs.d_currentMessage.impl();
 
    return lend && rend;
}
 
inline bool blpapi::operator!=(
        Event::iterator const& lhs, Event::iterator const& rhs)
{
    return !(lhs == rhs);
}
 
inline void blpapi::swap(Event::iterator& lhs, Event::iterator& rhs)
{
    lhs.swap(rhs);
}
 
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_EVENT