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>
#include <blpapi_versionmacros.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);
 
BLPAPI_EXPORT
int blpapi_UserAgentInfo_setUserTaskName(const char *userTaskName);
 
BLPAPI_EXPORT
int blpapi_UserAgentInfo_setNativeSdkLanguageAndVersion(
        const char *language, const char *version);
 
#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)
{
    // Ignore the return value
    BLPAPI_CALL(blpapi_UserAgentInfo_setNativeSdkLanguageAndVersion)
    ("C++", BLPAPI_SDK_VERSION_STRING);
}
 
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