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();
        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);
class EventQueue {

    blpapi_EventQueue_t *d_handle_p;

  public:
    EventQueue();
    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;

    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 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);
}

} // 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