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

#ifndef INCLUDED_BLPAPI_MESSAGE
#include <blpapi_message.h>
#endif

#ifndef INCLUDED_BLPAPI_DEFS
#include <blpapi_defs.h>
#endif

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

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

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

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;

  private:
    MessageIterator(const MessageIterator&);
    MessageIterator& operator=(const MessageIterator&);

  public:
    MessageIterator(const Event& event);
    ~MessageIterator();
    bool next();
    bool isValid() const;
    Message message(bool createClonable = false) const;
};

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

// ----------------
// 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(0)
    , d_current_p(0)
{
    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);
}

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

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_EVENT