blpapi_abstractsession.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_ABSTRACTSESSION
#define INCLUDED_BLPAPI_ABSTRACTSESSION

#include <blpapi_authoptions.h>
#include <blpapi_call.h>
#include <blpapi_correlationid.h>
#include <blpapi_defs.h>
#include <blpapi_deprecate.h>
#include <blpapi_event.h>
#include <blpapi_eventdispatcher.h>
#include <blpapi_exception.h>
#include <blpapi_identity.h>
#include <blpapi_request.h>
#include <blpapi_service.h>
#include <blpapi_types.h>

#ifdef __cplusplus
extern "C" {
#endif

// All of the blpapi_UserHandle_* functions have been deprecated. Please use
// blpapi_Identity_* versions of these functions instead.

BLPAPI_EXPORT
void blpapi_UserHandle_release(blpapi_UserHandle_t *handle);

BLPAPI_EXPORT
int blpapi_UserHandle_addRef(blpapi_UserHandle_t *handle);

BLPAPI_EXPORT
int blpapi_UserHandle_hasEntitlements(const blpapi_UserHandle_t *handle,
        const blpapi_Service_t *service,
        const blpapi_Element_t *eidElement,
        const int *entitlementIds,
        size_t numEntitlements,
        int *failedEntitlements,
        int *failedEntitlementsCount);

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

BLPAPI_EXPORT
int blpapi_AbstractSession_sendAuthorizationRequest(
        blpapi_AbstractSession_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_AbstractSession_openService(
        blpapi_AbstractSession_t *session, const char *serviceIdentifier);

BLPAPI_EXPORT
int blpapi_AbstractSession_openServiceAsync(blpapi_AbstractSession_t *session,
        const char *serviceIdentifier,
        blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_AbstractSession_generateToken(blpapi_AbstractSession_t *session,
        blpapi_CorrelationId_t *correlationId,
        blpapi_EventQueue_t *eventQueue);

BLPAPI_EXPORT
int blpapi_AbstractSession_generateManualToken(
        blpapi_AbstractSession_t *session,
        blpapi_CorrelationId_t *correlationId,
        const char *user,
        const char *manualIp,
        blpapi_EventQueue_t *eventQueue);

BLPAPI_EXPORT
int blpapi_AbstractSession_getService(blpapi_AbstractSession_t *session,
        blpapi_Service_t **service,
        const char *serviceIdentifier);

BLPAPI_EXPORT
blpapi_Identity_t *blpapi_AbstractSession_createIdentity(
        blpapi_AbstractSession_t *session);

BLPAPI_EXPORT
int blpapi_AbstractSession_generateAuthorizedIdentityAsync(
        blpapi_AbstractSession_t *session,
        const blpapi_AuthOptions_t *authOptions,
        blpapi_CorrelationId_t *cid);

BLPAPI_EXPORT
int blpapi_AbstractSession_getAuthorizedIdentity(
        blpapi_AbstractSession_t *session,
        const blpapi_CorrelationId_t *cid,
        blpapi_Identity_t **identity);

BLPAPI_EXPORT
int blpapi_AbstractSession_sessionName(blpapi_AbstractSession_t *session,
        const char **sessionName,
        size_t *size);

#ifdef __cplusplus
}

#include <cassert>
#include <vector>

namespace BloombergLP {
namespace blpapi {

typedef Identity UserHandle;

// =====================
// class AbstractSession
// =====================

class AbstractSession {

    blpapi_AbstractSession_t *d_handle_p;

  private:
    // NOT IMPLEMENTED
    AbstractSession(const AbstractSession&);
    AbstractSession& operator=(const AbstractSession&);

  protected:
    AbstractSession();
    void initAbstractSessionHandle(blpapi_AbstractSession_t *handle);

  public:
    virtual ~AbstractSession();
    // MANIPULATORS
    virtual bool start() = 0;
    virtual bool startAsync() = 0;
    virtual void stop() = 0;
    virtual void stopAsync() = 0;
    virtual Event nextEvent(int timeout = 0) = 0;
    virtual int tryNextEvent(Event *event) = 0;
    virtual bool openService(const char *serviceIdentifier);
    virtual CorrelationId openServiceAsync(const char *serviceIdentifier,
            const CorrelationId& correlationId = CorrelationId());
    virtual CorrelationId sendAuthorizationRequest(
            const Request& authorizationRequest,
            Identity *identity,
            const CorrelationId& correlationId = CorrelationId(),
            EventQueue *eventQueue = 0);
    virtual void cancel(const CorrelationId& correlationId);
    virtual void cancel(const std::vector<CorrelationId>& correlationIds);
    virtual void cancel(
            const CorrelationId *correlationIds, size_t numCorrelationIds);
    virtual CorrelationId generateToken(
            const CorrelationId& correlationId = CorrelationId(),
            EventQueue *eventQueue = 0);
    virtual CorrelationId generateToken(const char *userId,
            const char *ipAddress,
            const CorrelationId& correlationId = CorrelationId(),
            EventQueue *eventQueue = 0);
    virtual Service getService(const char *serviceIdentifier) const;
    virtual Identity createIdentity();
    CorrelationId generateAuthorizedIdentity(const AuthOptions& authOptions,
            const CorrelationId& cid = CorrelationId());
    Identity getAuthorizedIdentity(
            const CorrelationId& correlationId = CorrelationId());
    std::string sessionName();
    blpapi_AbstractSession_t *abstractSessionHandle() const;

    BLPAPI_DEPRECATE_ABSTRACT_SESSION_CREATE_USER_HANDLE UserHandle
    createUserHandle();
};

//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================

// ---------------------
// class AbstractSession
// ---------------------

inline AbstractSession::AbstractSession()
    : d_handle_p(0)
{
}

inline AbstractSession::~AbstractSession() { }

inline void AbstractSession::initAbstractSessionHandle(
        blpapi_AbstractSession_t *handle)
{
    d_handle_p = handle;
}

inline Service AbstractSession::getService(const char *serviceIdentifier) const
{
    blpapi_Service_t *service;
    ExceptionUtil::throwOnError(blpapi_AbstractSession_getService(
            d_handle_p, &service, serviceIdentifier));
    return Service(service);
}

inline CorrelationId AbstractSession::sendAuthorizationRequest(
        const Request& authorizationRequest,
        Identity *identity,
        const CorrelationId& correlationId,
        EventQueue *eventQueue)
{
    assert(identity);

    CorrelationId retCorrelationId(correlationId);

    ExceptionUtil::throwOnError(
            blpapi_AbstractSession_sendAuthorizationRequest(d_handle_p,
                    authorizationRequest.handle(),
                    identity->handle(),
                    const_cast<blpapi_CorrelationId_t *>(
                            &retCorrelationId.impl()),
                    eventQueue ? eventQueue->handle() : 0,
                    0,
                    0));

    return retCorrelationId;
}

inline void AbstractSession::cancel(const CorrelationId& correlationId)
{
    blpapi_AbstractSession_cancel(d_handle_p, &correlationId.impl(), 1, 0, 0);
}

inline void AbstractSession::cancel(
        const std::vector<CorrelationId>& correlationIds)
{
    if (!correlationIds.size()) {
        return;
    }
    cancel(&correlationIds[0], correlationIds.size());
}

inline void AbstractSession::cancel(
        const CorrelationId *correlationIds, size_t numCorrelationIds)
{
    blpapi_AbstractSession_cancel(d_handle_p,
            reinterpret_cast<const blpapi_CorrelationId_t *>(correlationIds),
            numCorrelationIds,
            0,
            0);
}

inline CorrelationId AbstractSession::generateToken(
        const CorrelationId& correlationId, EventQueue *eventQueue)
{
    CorrelationId retCorrelationId(correlationId);

    ExceptionUtil::throwOnError(
            blpapi_AbstractSession_generateToken(d_handle_p,
                    &retCorrelationId.impl(),
                    eventQueue ? eventQueue->handle() : 0));

    return retCorrelationId;
}

inline CorrelationId AbstractSession::generateToken(const char *userId,
        const char *ipAddress,
        const CorrelationId& correlationId,
        EventQueue *eventQueue)
{
    CorrelationId retCorrelationId(correlationId);

    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AbstractSession_generateManualToken)(d_handle_p,
                    &retCorrelationId.impl(),
                    userId,
                    ipAddress,
                    eventQueue ? eventQueue->handle() : 0));

    return retCorrelationId;
}

inline bool AbstractSession::openService(const char *serviceIdentifier)
{
    return blpapi_AbstractSession_openService(d_handle_p, serviceIdentifier)
            ? false
            : true;
}

inline CorrelationId AbstractSession::openServiceAsync(
        const char *serviceIdentifier, const CorrelationId& correlationId)
{
    blpapi_CorrelationId_t retv = correlationId.impl();
    ExceptionUtil::throwOnError(blpapi_AbstractSession_openServiceAsync(
            d_handle_p, serviceIdentifier, &retv));

    return CorrelationId(retv);
}

inline UserHandle AbstractSession::createUserHandle()
{
    return UserHandle(blpapi_AbstractSession_createIdentity(d_handle_p));
}

inline Identity AbstractSession::createIdentity()
{
    return Identity(blpapi_AbstractSession_createIdentity(d_handle_p));
}

inline CorrelationId AbstractSession::generateAuthorizedIdentity(
        const AuthOptions& authOptions, const CorrelationId& cid)
{
    blpapi_CorrelationId_t cidHandle = cid.impl();

    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_AbstractSession_generateAuthorizedIdentityAsync)(
            d_handle_p, authOptions.handle(), &cidHandle));

    return CorrelationId(cidHandle);
}

inline Identity AbstractSession::getAuthorizedIdentity(
        const CorrelationId& correlationId)
{
    blpapi_Identity_t *identity = NULL;

    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AbstractSession_getAuthorizedIdentity)(
                    d_handle_p, &correlationId.impl(), &identity));

    return Identity(identity);
}

inline std::string AbstractSession::sessionName()
{
    const char *sessionName = nullptr;
    size_t size = 0;

    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AbstractSession_sessionName)(
                    d_handle_p, &sessionName, &size));
    return std::string(sessionName, size);
}

inline blpapi_AbstractSession_t *AbstractSession::abstractSessionHandle() const
{
    return d_handle_p;
}

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

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_ABSTRACTSESSION