blpapi_session.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_SESSION
#define INCLUDED_BLPAPI_SESSION

 
#include <blpapi_abstractsession.h>
#include <blpapi_call.h>
#include <blpapi_correlationid.h>
#include <blpapi_defs.h>
#include <blpapi_event.h>
#include <blpapi_eventdispatcher.h>
#include <blpapi_identity.h>
#include <blpapi_request.h>
#include <blpapi_requesttemplate.h>
#include <blpapi_service.h>
#include <blpapi_sessionoptions.h>
#include <blpapi_subscriptionlist.h>
#include <blpapi_types.h>
 
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif



typedef void (*blpapi_EventHandler_t)(
        blpapi_Event_t *event, blpapi_Session_t *session, void *userData);

typedef void (*blpapi_SubscriptionPreprocessErrorHandler_t)(
        const blpapi_CorrelationId_t *correlationId,
        const char *subscriptionString,
        int errorCode,
        const char *errorDescription,
        void *userData);

BLPAPI_EXPORT
blpapi_Session_t *blpapi_Session_create(blpapi_SessionOptions_t *parameters,
        blpapi_EventHandler_t handler,
        blpapi_EventDispatcher_t *dispatcher,
        void *userData);

BLPAPI_EXPORT
void blpapi_Session_destroy(blpapi_Session_t *session);

BLPAPI_EXPORT
int blpapi_Session_start(blpapi_Session_t *session);

BLPAPI_EXPORT
int blpapi_Session_startAsync(blpapi_Session_t *session);

BLPAPI_EXPORT
int blpapi_Session_stop(blpapi_Session_t *session);

BLPAPI_EXPORT
int blpapi_Session_stopAsync(blpapi_Session_t *session);

BLPAPI_EXPORT
int blpapi_Session_nextEvent(blpapi_Session_t *session,
        blpapi_Event_t **eventPointer,
        unsigned int timeoutInMilliseconds);

BLPAPI_EXPORT
int blpapi_Session_tryNextEvent(
        blpapi_Session_t *session, blpapi_Event_t **eventPointer);

BLPAPI_EXPORT
int blpapi_Session_subscribe(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *subscriptionList,
        const blpapi_Identity_t *handle,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_subscribeEx(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *subscriptionList,
        const blpapi_Identity_t *handle,
        const char *requestLabel,
        int requestLabelLen,
        blpapi_SubscriptionPreprocessErrorHandler_t errorHandler,
        void *userData);

BLPAPI_EXPORT
int blpapi_Session_resubscribe(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *resubscriptionList,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_resubscribeEx(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *resubscriptionList,
        const char *requestLabel,
        int requestLabelLen,
        blpapi_SubscriptionPreprocessErrorHandler_t errorHandler,
        void *userData);

BLPAPI_EXPORT
int blpapi_Session_resubscribeWithId(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *resubscriptionList,
        int resubscriptionId,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_resubscribeWithIdEx(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *resubscriptionList,
        int resubscriptionId,
        const char *requestLabel,
        int requestLabelLen,
        blpapi_SubscriptionPreprocessErrorHandler_t errorHandler,
        void *userData);

BLPAPI_EXPORT
int blpapi_Session_unsubscribe(blpapi_Session_t *session,
        const blpapi_SubscriptionList_t *unsubscriptionList,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_cancel(blpapi_Session_t *session,
        const blpapi_CorrelationId_t *correlationIds,
        size_t numCorrelationIds,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_setStatusCorrelationId(blpapi_Session_t *session,
        const blpapi_Service_t *service,
        const blpapi_Identity_t *identity,
        const blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_Session_sendRequest(blpapi_Session_t *session,
        const blpapi_Request_t *request,
        blpapi_CorrelationId_t *correlationId,
        blpapi_Identity_t *identity,
        blpapi_EventQueue_t *eventQueue,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_sendRequestTemplate(blpapi_Session_t *session,
        const blpapi_RequestTemplate_t *requestTemplate,
        blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_Session_createSnapshotRequestTemplate(
        blpapi_RequestTemplate_t **requestTemplate,
        blpapi_Session_t *session,
        const char *subscriptionString,
        const blpapi_Identity_t *identity,
        blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_Session_sendAuthorizationRequest(blpapi_Session_t *session,
        const blpapi_Request_t *request,
        blpapi_Identity_t *identity,
        blpapi_CorrelationId_t *correlationId,
        blpapi_EventQueue_t *eventQueue,
        const char *requestLabel,
        int requestLabelLen);

BLPAPI_EXPORT
int blpapi_Session_openService(
        blpapi_Session_t *session, const char *serviceName);

BLPAPI_EXPORT
int blpapi_Session_openServiceAsync(blpapi_Session_t *session,
        const char *serviceName,
        blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_Session_generateToken(blpapi_Session_t *session,
        blpapi_CorrelationId_t *correlationId,
        blpapi_EventQueue_t *eventQueue);

BLPAPI_EXPORT
int blpapi_Session_getService(blpapi_Session_t *session,
        blpapi_Service_t **service,
        const char *serviceName);

BLPAPI_EXPORT
blpapi_UserHandle_t *blpapi_Session_createUserHandle(
        blpapi_Session_t *session);

BLPAPI_EXPORT
blpapi_Identity_t *blpapi_Session_createIdentity(blpapi_Session_t *session);

BLPAPI_EXPORT
blpapi_AbstractSession_t *blpapi_Session_getAbstractSession(
        blpapi_Session_t *session);

BLPAPI_EXPORT
blpapi_SubscriptionIterator_t *blpapi_SubscriptionItr_create(
        blpapi_Session_t *session);

BLPAPI_EXPORT
void blpapi_SubscriptionItr_destroy(blpapi_SubscriptionIterator_t *iterator);

BLPAPI_EXPORT
int blpapi_SubscriptionItr_next(blpapi_SubscriptionIterator_t *iterator,
        const char **subscriptionString,
        blpapi_CorrelationId_t *correlationId,
        int *status);

BLPAPI_EXPORT
int blpapi_SubscriptionItr_isValid(
        const blpapi_SubscriptionIterator_t *iterator);

 
#ifdef __cplusplus
}
 
#include <cassert>
#include <cstring> // for std::memset
 
namespace BloombergLP {
namespace blpapi {
 
class Session;

class EventHandler {
 
  public:
    virtual ~EventHandler() = 0;
 
    virtual bool processEvent(const Event& event, Session *session) = 0;
};

extern "C" void blpapi_eventHandlerAdapter(
        blpapi_Event_t *event, blpapi_Session_t *, void *userData);
 
struct SubscriptionPreprocessError {
    enum Code {
        e_invalidSubscriptionString
        = BLPAPI_SUBSCRIPTIONPREPROCESS_INVALID_SUBSCRIPTION_STRING,
 
        e_correlationIdError
        = BLPAPI_SUBSCRIPTIONPREPROCESS_CORRELATIONID_ERROR
    };
 
    CorrelationId correlationId;
    std::string subscriptionString;
    int code;
    /*
     *     The error code that is one of `Code` enum values.
     */
    std::string description;
 
    SubscriptionPreprocessError(const CorrelationId& correlationId,
            const std::string& subscriptionString,
            int code,
            const char *description)
        : correlationId(correlationId)
        , subscriptionString(subscriptionString)
        , code(code)
        , description(description)
    {
    }
};
 
inline std::ostream& operator<<(
        std::ostream& os, const SubscriptionPreprocessError& error)
{
    os << "{" << "correlationId: " << error.correlationId
       << ", subscriptionString: " << error.subscriptionString << ", code: ";
    if (error.code
            == SubscriptionPreprocessError::e_invalidSubscriptionString) {
        os << "InvalidSubscriptionString";
    } else if (error.code
            == SubscriptionPreprocessError::e_correlationIdError) {
        os << "CorrelationIdError";
    } else {
        os << "UNKNOWN";
    }
 
    os << "(" << error.code << ")";
    os << ", description: " << error.description << "}";
 
    return os;
}

extern "C" inline void blpapi_SubscriptionPreprocess_handleError(
        const blpapi_CorrelationId_t *correlationId,
        const char *subscriptionString,
        int errorCode,
        const char *description,
        void *userData)
{
    typedef std::vector<SubscriptionPreprocessError> Errors;
    Errors *errors = reinterpret_cast<Errors *>(userData);
    errors->emplace_back(CorrelationId(*correlationId),
            subscriptionString,
            errorCode,
            description);
}
 
struct SubscriptionPreprocessMode {
    enum Enum {
 
        e_failOnFirstError,
 
        e_returnIndividualErrors
    };
};
 
typedef std::vector<SubscriptionPreprocessError> SubscriptionPreprocessErrors;

class Session : public AbstractSession {
 
  public:
    typedef ::BloombergLP::blpapi::EventHandler EventHandler;
 
  private:
    blpapi_Session_t *d_handle_p;
    EventHandler *d_eventHandler_p;
 
    // NOT IMPLEMENTED
    Session(const Session&);
    Session& operator=(const Session&);
 
    friend void blpapi_eventHandlerAdapter(
            blpapi_Event_t *event, blpapi_Session_t *, void *userData);
 
  public:
    /*
     *     The possible statuses a subscription may be in.
     */
    enum SubscriptionStatus {
        UNSUBSCRIBED = BLPAPI_SUBSCRIPTIONSTATUS_UNSUBSCRIBED,
        SUBSCRIBING = BLPAPI_SUBSCRIPTIONSTATUS_SUBSCRIBING,
        SUBSCRIBED = BLPAPI_SUBSCRIPTIONSTATUS_SUBSCRIBED,
        CANCELLED = BLPAPI_SUBSCRIPTIONSTATUS_CANCELLED,
        PENDING_CANCELLATION = BLPAPI_SUBSCRIPTIONSTATUS_PENDING_CANCELLATION
    };
 
    explicit Session(const SessionOptions& options = SessionOptions(),
            EventHandler *eventHandler = 0,
            EventDispatcher *eventDispatcher = 0);
 
    explicit Session(blpapi_Session_t *handle);
 
    virtual ~Session();
 
    virtual bool start();
 
    virtual bool startAsync();
 
    virtual void stop();
 
    virtual void stopAsync();
 
    virtual Event nextEvent(int timeout = 0);
 
    virtual int tryNextEvent(Event *event);
 
    virtual void subscribe(const SubscriptionList& subscriptionList,
            const Identity& identity,
            const char *requestLabel = 0,
            int requestLabelLen = 0);
 
    virtual SubscriptionPreprocessErrors subscribe(
            const SubscriptionList& subscriptionList,
            const Identity& identity,
            SubscriptionPreprocessMode::Enum mode,
            const char *requestLabel = 0,
            int requestLabelLen = 0);
 
    virtual void subscribe(const SubscriptionList& subscriptionList,
            const char *requestLabel = 0,
            int requestLabelLen = 0);
 
    virtual SubscriptionPreprocessErrors subscribe(
            const SubscriptionList& subscriptionList,
            SubscriptionPreprocessMode::Enum mode,
            const char *requestLabel = 0,
            int requestLabelLen = 0);
 
    virtual void unsubscribe(const SubscriptionList& subscriptionList);
 
    virtual void resubscribe(const SubscriptionList& subscriptions);
 
    virtual SubscriptionPreprocessErrors resubscribe(
            const SubscriptionList& subscriptions,
            SubscriptionPreprocessMode::Enum mode);
 
    virtual void resubscribe(const SubscriptionList& subscriptions,
            const char *requestLabel,
            int requestLabelLen);
 
    virtual SubscriptionPreprocessErrors resubscribe(
            const SubscriptionList& subscriptions,
            const char *requestLabel,
            int requestLabelLen,
            SubscriptionPreprocessMode::Enum mode);
 
    virtual void resubscribe(
            const SubscriptionList& subscriptions, int resubscriptionId);
 
    virtual SubscriptionPreprocessErrors resubscribe(
            const SubscriptionList& subscriptions,
            int resubscriptionId,
            SubscriptionPreprocessMode::Enum mode);
 
    virtual void resubscribe(const SubscriptionList& subscriptions,
            int resubscriptionId,
            const char *requestLabel,
            int requestLabelLen);
 
    virtual SubscriptionPreprocessErrors resubscribe(
            const SubscriptionList& subscriptions,
            int resubscriptionId,
            const char *requestLabel,
            int requestLabelLen,
            SubscriptionPreprocessMode::Enum mode);
 
    virtual void setStatusCorrelationId(
            const Service& service, const CorrelationId& correlationID);
 
    virtual void setStatusCorrelationId(const Service& service,
            const Identity& identity,
            const CorrelationId& correlationID);
 
    virtual CorrelationId sendRequest(const Request& request,
            const CorrelationId& correlationId = CorrelationId(),
            EventQueue *eventQueue = 0,
            const char *requestLabel = 0,
            int requestLabelLen = 0);
 
    virtual CorrelationId sendRequest(const Request& request,
            const Identity& user,
            const CorrelationId& correlationId = CorrelationId(),
            EventQueue *eventQueue = 0,
            const char *requestLabel = 0,
            int requestLabelLen = 0);
 
    virtual CorrelationId sendRequest(const RequestTemplate& requestTemplate,
            const CorrelationId& correlationId = CorrelationId());
 
    virtual RequestTemplate createSnapshotRequestTemplate(
            const char *subscriptionString,
            const CorrelationId& statusCid,
            const Identity& identity = Identity());

    blpapi_Session_t *handle() const;
};

class SubscriptionIterator {
 
    blpapi_SubscriptionIterator_t *d_handle_p;
    const char *d_subscriptionString;
    CorrelationId d_correlationId;
    int d_status;
    bool d_isValid;
 
  private:
    // NOT IMPLEMENTED
    SubscriptionIterator(const SubscriptionIterator&);
    SubscriptionIterator& operator=(const SubscriptionIterator&);
 
  public:
    explicit SubscriptionIterator(Session *session);
 
    ~SubscriptionIterator();
 
    // MANIPULATORS
 
    bool next();
 
    // ACCESSORS
 
    bool isValid() const;
 
    const char *subscriptionString() const;
 
    const CorrelationId& correlationId() const;
 
    Session::SubscriptionStatus subscriptionStatus() const;

    blpapi_SubscriptionIterator_t *handle() const;
};

 
namespace util {

 
constexpr const char *to_string(SubscriptionPreprocessError::Code code);
 
constexpr const char *to_string(SubscriptionPreprocessMode::Enum mode);
 
constexpr const char *to_string(Session::SubscriptionStatus status);

 
} // close namespace util
 
// ============================================================================
//                      INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// ------------------
// class EventHandler
// ------------------
 
inline EventHandler::~EventHandler() { }
 
// FREE FUNCTIONS
extern "C" inline void blpapi_eventHandlerAdapter(
        blpapi_Event_t *event, blpapi_Session_t *, void *userData)
{
    Session *session = reinterpret_cast<Session *>(userData);
    assert(session);
    assert(session->d_eventHandler_p);
    session->d_eventHandler_p->processEvent(Event(event), session);
}
 
// -------------
// class Session
// -------------
 
inline Session::Session(const SessionOptions& parameters,
        EventHandler *handler,
        EventDispatcher *dispatcher)
    : d_eventHandler_p(handler)
{
    if (dispatcher && !handler) {
        throw InvalidArgumentException(
                "Event dispatcher provided without handler.");
    }
    d_handle_p = blpapi_Session_create(parameters.handle(),
            handler ? &blpapi_eventHandlerAdapter : 0,
            dispatcher ? dispatcher->impl() : 0,
            this);
    initAbstractSessionHandle(blpapi_Session_getAbstractSession(d_handle_p));
}
 
inline Session::Session(blpapi_Session_t *newHandle)
    : d_handle_p(newHandle)
{
    initAbstractSessionHandle(blpapi_Session_getAbstractSession(d_handle_p));
}
 
inline Session::~Session() { blpapi_Session_destroy(d_handle_p); }
 
inline bool Session::start()
{
    return blpapi_Session_start(d_handle_p) ? false : true;
}
 
inline bool Session::startAsync()
{
    return blpapi_Session_startAsync(d_handle_p) ? false : true;
}
 
inline void Session::stop() { blpapi_Session_stop(d_handle_p); }
 
inline void Session::stopAsync() { blpapi_Session_stopAsync(d_handle_p); }
 
inline Event Session::nextEvent(int timeout)
{
    if (timeout < 0) {
        throw InvalidArgumentException("Timeout must be >= 0.");
    }
 
    blpapi_Event_t *event = 0;
    ExceptionUtil::throwOnError(blpapi_Session_nextEvent(
            d_handle_p, &event, static_cast<unsigned>(timeout)));
    return Event(event);
}
 
inline int Session::tryNextEvent(Event *event)
{
    blpapi_Event_t *impl = 0;
    int ret = blpapi_Session_tryNextEvent(d_handle_p, &impl);
    if (0 == ret) {
        assert(event);
 
        *event = Event(impl);
    }
    return ret;
}
 
inline void Session::subscribe(const SubscriptionList& subscriptions,
        const char *requestLabel,
        int requestLabelLen)
{
    ExceptionUtil::throwOnError(blpapi_Session_subscribe(d_handle_p,
            subscriptions.impl(),
            0, // identityHandle
            requestLabel,
            requestLabelLen));
}
 
inline SubscriptionPreprocessErrors Session::subscribe(
        const SubscriptionList& subscriptions,
        SubscriptionPreprocessMode::Enum mode,
        const char *requestLabel,
        int requestLabelLen)
{
    SubscriptionPreprocessErrors errors;
    if (mode == SubscriptionPreprocessMode::e_failOnFirstError) {
        subscribe(subscriptions, requestLabel, requestLabelLen);
    } else {
        ExceptionUtil::throwOnError(
                BLPAPI_CALL(blpapi_Session_subscribeEx)(d_handle_p,
                        subscriptions.impl(),
                        0, // identityHandle
                        requestLabel,
                        requestLabelLen,
                        &blpapi_SubscriptionPreprocess_handleError,
                        &errors));
    }
 
    return errors;
}
 
inline void Session::subscribe(const SubscriptionList& subscriptions,
        const Identity& identity,
        const char *requestLabel,
        int requestLabelLen)
{
    ExceptionUtil::throwOnError(blpapi_Session_subscribe(d_handle_p,
            subscriptions.impl(),
            identity.handle(),
            requestLabel,
            requestLabelLen));
}
 
inline SubscriptionPreprocessErrors Session::subscribe(
        const SubscriptionList& subscriptions,
        const Identity& identity,
        SubscriptionPreprocessMode::Enum mode,
        const char *requestLabel,
        int requestLabelLen)
{
    SubscriptionPreprocessErrors errors;
    if (mode == SubscriptionPreprocessMode::e_failOnFirstError) {
        subscribe(subscriptions, identity, requestLabel, requestLabelLen);
    } else {
        ExceptionUtil::throwOnError(
                BLPAPI_CALL(blpapi_Session_subscribeEx)(d_handle_p,
                        subscriptions.impl(),
                        identity.handle(),
                        requestLabel,
                        requestLabelLen,
                        &blpapi_SubscriptionPreprocess_handleError,
                        &errors));
    }
 
    return errors;
}
 
inline void Session::resubscribe(const SubscriptionList& subscriptions)
{
    ExceptionUtil::throwOnError(blpapi_Session_resubscribe(d_handle_p,
            subscriptions.impl(),
            0, // requestLabel
            0)); // requestLabelLen
}
 
inline SubscriptionPreprocessErrors Session::resubscribe(
        const SubscriptionList& subscriptions,
        SubscriptionPreprocessMode::Enum mode)
{
    SubscriptionPreprocessErrors errors;
    if (mode == SubscriptionPreprocessMode::e_failOnFirstError) {
        resubscribe(subscriptions);
    } else {
        ExceptionUtil::throwOnError(
                BLPAPI_CALL(blpapi_Session_resubscribeEx)(d_handle_p,
                        subscriptions.impl(),
                        0, // requestLabel
                        0, // requestLabelLen
                        &blpapi_SubscriptionPreprocess_handleError,
                        &errors));
    }
 
    return errors;
}
 
inline void Session::resubscribe(const SubscriptionList& subscriptions,
        const char *requestLabel,
        int requestLabelLen)
{
    ExceptionUtil::throwOnError(blpapi_Session_resubscribe(
            d_handle_p, subscriptions.impl(), requestLabel, requestLabelLen));
}
 
inline SubscriptionPreprocessErrors Session::resubscribe(
        const SubscriptionList& subscriptions,
        const char *requestLabel,
        int requestLabelLen,
        SubscriptionPreprocessMode::Enum mode)
{
    SubscriptionPreprocessErrors errors;
    if (mode == SubscriptionPreprocessMode::e_failOnFirstError) {
        resubscribe(subscriptions, requestLabel, requestLabelLen);
    } else {
        ExceptionUtil::throwOnError(
                BLPAPI_CALL(blpapi_Session_resubscribeEx)(d_handle_p,
                        subscriptions.impl(),
                        requestLabel,
                        requestLabelLen,
                        &blpapi_SubscriptionPreprocess_handleError,
                        &errors));
    }
 
    return errors;
}
 
inline void Session::resubscribe(
        const SubscriptionList& subscriptions, int resubscriptionId)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSION_RESUBSCRIBEWITHID(d_handle_p,
                    subscriptions.impl(),
                    resubscriptionId,
                    0, // requestLabel
                    0)); // requestLabelLen
}
 
inline SubscriptionPreprocessErrors Session::resubscribe(
        const SubscriptionList& subscriptions,
        int resubscriptionId,
        SubscriptionPreprocessMode::Enum mode)
{
    SubscriptionPreprocessErrors errors;
    if (mode == SubscriptionPreprocessMode::e_failOnFirstError) {
        resubscribe(subscriptions, resubscriptionId);
    } else {
        ExceptionUtil::throwOnError(
                BLPAPI_CALL(blpapi_Session_resubscribeWithIdEx)(d_handle_p,
                        subscriptions.impl(),
                        resubscriptionId,
                        0, // requestLabel
                        0, // requestLabelLen
                        &blpapi_SubscriptionPreprocess_handleError,
                        &errors));
    }
 
    return errors;
}
 
inline void Session::resubscribe(const SubscriptionList& subscriptions,
        int resubscriptionId,
        const char *requestLabel,
        int requestLabelLen)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSION_RESUBSCRIBEWITHID(d_handle_p,
                    subscriptions.impl(),
                    resubscriptionId,
                    requestLabel,
                    requestLabelLen));
}
 
inline SubscriptionPreprocessErrors Session::resubscribe(
        const SubscriptionList& subscriptions,
        int resubscriptionId,
        const char *requestLabel,
        int requestLabelLen,
        SubscriptionPreprocessMode::Enum mode)
{
    SubscriptionPreprocessErrors errors;
    if (mode == SubscriptionPreprocessMode::e_failOnFirstError) {
        resubscribe(subscriptions,
                resubscriptionId,
                requestLabel,
                requestLabelLen);
    } else {
        ExceptionUtil::throwOnError(
                BLPAPI_CALL(blpapi_Session_resubscribeWithIdEx)(d_handle_p,
                        subscriptions.impl(),
                        resubscriptionId,
                        requestLabel,
                        requestLabelLen,
                        &blpapi_SubscriptionPreprocess_handleError,
                        &errors));
    }
 
    return errors;
}
 
inline void Session::unsubscribe(const SubscriptionList& list)
{
    ExceptionUtil::throwOnError(
            blpapi_Session_unsubscribe(d_handle_p, list.impl(), 0, 0));
}
 
inline void Session::setStatusCorrelationId(
        const Service& service, const CorrelationId& correlationID)
{
    ExceptionUtil::throwOnError(blpapi_Session_setStatusCorrelationId(
            d_handle_p, service.handle(), 0, &correlationID.impl()));
}
 
inline void Session::setStatusCorrelationId(const Service& service,
        const Identity& identity,
        const CorrelationId& correlationID)
{
    ExceptionUtil::throwOnError(
            blpapi_Session_setStatusCorrelationId(d_handle_p,
                    service.handle(),
                    identity.handle(),
                    &correlationID.impl()));
}
 
inline CorrelationId Session::sendRequest(const Request& request,
        const Identity& identity,
        const CorrelationId& correlationId,
        EventQueue *eventQueue,
        const char *requestLabel,
        int requestLabelLen)
{
    CorrelationId retCorrelationId(correlationId);
 
    ExceptionUtil::throwOnError(blpapi_Session_sendRequest(d_handle_p,
            request.handle(),
            &retCorrelationId.impl(),
            identity.handle(),
            eventQueue ? eventQueue->handle() : 0,
            requestLabel,
            requestLabelLen));
 
    return retCorrelationId;
}
 
inline CorrelationId Session::sendRequest(const Request& request,
        const CorrelationId& correlationId,
        EventQueue *eventQueue,
        const char *requestLabel,
        int requestLabelLen)
{
    CorrelationId retCorrelationId(correlationId);
 
    ExceptionUtil::throwOnError(blpapi_Session_sendRequest(d_handle_p,
            request.handle(),
            &retCorrelationId.impl(),
            0,
            eventQueue ? eventQueue->handle() : 0,
            requestLabel,
            requestLabelLen));
 
    return retCorrelationId;
}
 
inline CorrelationId Session::sendRequest(
        const RequestTemplate& requestTemplate,
        const CorrelationId& correlationId)
{
    CorrelationId retCorrelationId(correlationId);
 
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_Session_sendRequestTemplate)(
            d_handle_p, requestTemplate.impl(), &retCorrelationId.impl()));
 
    return retCorrelationId;
}
 
inline RequestTemplate Session::createSnapshotRequestTemplate(
        const char *subscriptionString,
        const CorrelationId& correlationID,
        const Identity& identity)
{
    blpapi_RequestTemplate_t *requestTemplate = 0;
 
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_Session_createSnapshotRequestTemplate)(&requestTemplate,
            d_handle_p,
            subscriptionString,
            identity.handle(),
            const_cast<blpapi_CorrelationId_t *>(&correlationID.impl())));
 
    return RequestTemplate(requestTemplate);
}

inline blpapi_Session_t *Session::handle() const { return d_handle_p; }
 
// --------------------------
// class SubscriptionIterator
// --------------------------
 
inline SubscriptionIterator::SubscriptionIterator(Session *session)
    : d_isValid(false)
{
    assert(session);
 
    d_handle_p = blpapi_SubscriptionItr_create(session->handle());
}
 
inline SubscriptionIterator::~SubscriptionIterator()
{
    blpapi_SubscriptionItr_destroy(d_handle_p);
}
 
inline bool SubscriptionIterator::next()
{
    blpapi_CorrelationId_t nextCorrelationIdImpl;
    d_isValid = !blpapi_SubscriptionItr_next(d_handle_p,
            &d_subscriptionString,
            &nextCorrelationIdImpl,
            &d_status);
 
    d_correlationId = d_isValid ? CorrelationId(nextCorrelationIdImpl)
                                : CorrelationId();
 
    return d_isValid;
}
 
inline bool SubscriptionIterator::isValid() const { return d_isValid; }

inline blpapi_SubscriptionIterator_t *SubscriptionIterator::handle() const
{
    return d_handle_p;
}
 
inline const char *SubscriptionIterator::subscriptionString() const
{
    if (!isValid()) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ILLEGAL_STATE);
    }
 
    return d_subscriptionString;
}
 
inline const CorrelationId& SubscriptionIterator::correlationId() const
{
    if (!isValid()) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ILLEGAL_STATE);
    }
 
    return d_correlationId;
}
 
inline Session::SubscriptionStatus
SubscriptionIterator::subscriptionStatus() const
{
    if (!isValid()) {
        ExceptionUtil::throwOnError(BLPAPI_ERROR_ILLEGAL_STATE);
    }
 
    return static_cast<Session::SubscriptionStatus>(d_status);
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(SubscriptionPreprocessError::Code code)
{
    switch (code) {
    case SubscriptionPreprocessError::e_invalidSubscriptionString:
        return "e_invalidSubscriptionString";
    case SubscriptionPreprocessError::e_correlationIdError:
        return "e_correlationIdError";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(SubscriptionPreprocessMode::Enum mode)
{
    switch (mode) {
    case SubscriptionPreprocessMode::e_failOnFirstError:
        return "e_failOnFirstError";
    case SubscriptionPreprocessMode::e_returnIndividualErrors:
        return "e_returnIndividualErrors";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(Session::SubscriptionStatus status)
{
    switch (status) {
    case Session::UNSUBSCRIBED:
        return "UNSUBSCRIBED";
    case Session::SUBSCRIBING:
        return "SUBSCRIBING";
    case Session::SUBSCRIBED:
        return "SUBSCRIBED";
    case Session::CANCELLED:
        return "CANCELLED";
    case Session::PENDING_CANCELLATION:
        return "PENDING_CANCELLATION";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // ifdef __cplusplus
 
#endif // INCLUDED_BLPAPI_SESSION