blpapi_authoptions.h

Go to the documentation of this file.

/* Copyright 2019. 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_AUTHOPTIONS
#define INCLUDED_BLPAPI_AUTHOPTIONS

 
#include <blpapi_call.h>
#include <blpapi_defs.h>
#include <blpapi_exception.h>
#include <blpapi_types.h>
 
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif


 
BLPAPI_EXPORT
int blpapi_AuthOptions_create_default(blpapi_AuthOptions_t **options);
 
BLPAPI_EXPORT
int blpapi_AuthOptions_create_forUserMode(
        blpapi_AuthOptions_t **options, const blpapi_AuthUser_t *user);
 
BLPAPI_EXPORT
int blpapi_AuthOptions_create_forAppMode(
        blpapi_AuthOptions_t **options, const blpapi_AuthApplication_t *app);
 
BLPAPI_EXPORT
int blpapi_AuthOptions_create_forUserAndAppMode(blpapi_AuthOptions_t **options,
        const blpapi_AuthUser_t *user,
        const blpapi_AuthApplication_t *app);
 
BLPAPI_EXPORT
int blpapi_AuthOptions_create_forToken(
        blpapi_AuthOptions_t **options, const blpapi_AuthToken_t *token);
 
BLPAPI_EXPORT
int blpapi_AuthOptions_duplicate(
        blpapi_AuthOptions_t **options, const blpapi_AuthOptions_t *dup);
 
BLPAPI_EXPORT
int blpapi_AuthOptions_copy(
        blpapi_AuthOptions_t *lhs, const blpapi_AuthOptions_t *rhs);
 
BLPAPI_EXPORT
void blpapi_AuthOptions_destroy(blpapi_AuthOptions_t *options);
 
BLPAPI_EXPORT
int blpapi_AuthUser_createWithLogonName(blpapi_AuthUser_t **user);
 
BLPAPI_EXPORT
int blpapi_AuthUser_createWithActiveDirectoryProperty(
        blpapi_AuthUser_t **user, const char *propertyName);
 
BLPAPI_EXPORT
int blpapi_AuthUser_createWithManualOptions(
        blpapi_AuthUser_t **user, const char *userId, const char *ipAddress);
 
BLPAPI_EXPORT
int blpapi_AuthUser_duplicate(
        blpapi_AuthUser_t **user, const blpapi_AuthUser_t *dup);
 
BLPAPI_EXPORT
int blpapi_AuthUser_copy(blpapi_AuthUser_t *lhs, const blpapi_AuthUser_t *rhs);
 
BLPAPI_EXPORT
void blpapi_AuthUser_destroy(blpapi_AuthUser_t *user);
 
BLPAPI_EXPORT
int blpapi_AuthApplication_create(
        blpapi_AuthApplication_t **app, const char *appName);
 
BLPAPI_EXPORT
int blpapi_AuthApplication_duplicate(
        blpapi_AuthApplication_t **app, const blpapi_AuthApplication_t *dup);
 
BLPAPI_EXPORT
int blpapi_AuthApplication_copy(
        blpapi_AuthApplication_t *lhs, const blpapi_AuthApplication_t *rhs);
 
BLPAPI_EXPORT
void blpapi_AuthApplication_destroy(blpapi_AuthApplication_t *app);
 
BLPAPI_EXPORT
int blpapi_AuthToken_create(blpapi_AuthToken_t **token, const char *tokenStr);
 
BLPAPI_EXPORT
int blpapi_AuthToken_duplicate(
        blpapi_AuthToken_t **token, const blpapi_AuthToken_t *dup);
 
BLPAPI_EXPORT
int blpapi_AuthToken_copy(
        blpapi_AuthToken_t *lhs, const blpapi_AuthToken_t *rhs);
 
BLPAPI_EXPORT
void blpapi_AuthToken_destroy(blpapi_AuthToken_t *token);

 
#ifdef __cplusplus
}

 
namespace BloombergLP {
namespace blpapi {
 
class AuthUser;
class AuthApplication;
class AuthToken;
 
// =================
// class AuthOptions
// =================

class AuthOptions {
 
    blpapi_AuthOptions_t *d_handle_p;
 
  public:
    AuthOptions();
 
    AuthOptions(const AuthUser& user);
 
    AuthOptions(const AuthApplication& app);
 
    AuthOptions(const AuthUser& user, const AuthApplication& app);
 
    AuthOptions(const AuthToken& token);
 
    explicit AuthOptions(blpapi_AuthOptions_t *handle);
 
    AuthOptions(const AuthOptions& options);
 
    ~AuthOptions();
 
    AuthOptions& operator=(const AuthOptions& rhs);
 
    blpapi_AuthOptions_t *handle() const;
};
 
// =======================
// class AuthUser
// =======================

class AuthUser {
 
    blpapi_AuthUser_t *d_handle_p;
 
  public:
    explicit AuthUser(blpapi_AuthUser_t *handle);
 
    AuthUser(const AuthUser& user);
 
    ~AuthUser();
 
    AuthUser& operator=(const AuthUser& rhs);
 
    static AuthUser createWithLogonName();
 
    static AuthUser createWithActiveDirectoryProperty(
            const char *propertyName);
 
    static AuthUser createWithManualOptions(
            const char *userId, const char *ipAddress);
 
    const blpapi_AuthUser_t *handle() const;
};
 
// ==============================
// class AuthApplication
// ==============================

class AuthApplication {
 
    blpapi_AuthApplication_t *d_handle_p;
 
  public:
    explicit AuthApplication(const char *appName);
 
    explicit AuthApplication(blpapi_AuthApplication_t *handle);
 
    AuthApplication(const AuthApplication& app);
 
    ~AuthApplication();
 
    AuthApplication& operator=(const AuthApplication& rhs);
 
    const blpapi_AuthApplication_t *handle() const;
};
 
// ========================
// class AuthToken
// ========================

class AuthToken {
 
    blpapi_AuthToken_t *d_handle_p;
 
  public:
    explicit AuthToken(const char *tokenStr);
 
    explicit AuthToken(blpapi_AuthToken_t *handle);
 
    AuthToken(const AuthToken& token);
 
    ~AuthToken();
 
    AuthToken& operator=(const AuthToken& rhs);
 
    const blpapi_AuthToken_t *handle() const;
};

 
// ============================================================================
//                      INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// =================
// class AuthOptions
// =================
 
inline AuthOptions::AuthOptions()
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthOptions_create_default)(&d_handle_p));
}
 
inline AuthOptions::AuthOptions(const AuthUser& user)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthOptions_create_forUserMode)(
                    &d_handle_p, user.handle()));
}
 
inline AuthOptions::AuthOptions(const AuthApplication& app)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_AuthOptions_create_forAppMode)(&d_handle_p, app.handle()));
}
 
inline AuthOptions::AuthOptions(
        const AuthUser& user, const AuthApplication& app)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthOptions_create_forUserAndAppMode)(
                    &d_handle_p, user.handle(), app.handle()));
}
 
inline AuthOptions::AuthOptions(const AuthToken& token)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_AuthOptions_create_forToken)(&d_handle_p, token.handle()));
}
 
inline AuthOptions::AuthOptions(blpapi_AuthOptions_t *handle)
    : d_handle_p(handle)
{
}
 
inline AuthOptions::AuthOptions(const AuthOptions& options)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_AuthOptions_duplicate)(
            &d_handle_p, options.handle()));
}
 
inline AuthOptions::~AuthOptions()
{
    BLPAPI_CALL_UNCHECKED(blpapi_AuthOptions_destroy)(d_handle_p);
}
 
inline AuthOptions& AuthOptions::operator=(const AuthOptions& rhs)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthOptions_copy)(d_handle_p, rhs.handle()));
 
    return *this;
}
 
inline blpapi_AuthOptions_t *AuthOptions::handle() const { return d_handle_p; }
 
// =======================
// class AuthUser
// =======================
 
inline AuthUser::AuthUser(blpapi_AuthUser_t *handle)
    : d_handle_p(handle)
{
}
 
inline AuthUser::AuthUser(const AuthUser& user)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_AuthUser_duplicate)(
            &d_handle_p, user.handle()));
}
 
inline AuthUser::~AuthUser()
{
    BLPAPI_CALL_UNCHECKED(blpapi_AuthUser_destroy)(d_handle_p);
}
 
inline AuthUser& AuthUser::operator=(const AuthUser& rhs)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthUser_copy)(d_handle_p, rhs.handle()));
 
    return *this;
}
 
inline AuthUser AuthUser::createWithLogonName()
{
    blpapi_AuthUser_t *handle = NULL;
 
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthUser_createWithLogonName)(&handle));
 
    AuthUser user(handle);
 
    return user;
}
 
inline AuthUser AuthUser::createWithActiveDirectoryProperty(
        const char *propertyName)
{
    blpapi_AuthUser_t *handle = NULL;
 
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthUser_createWithActiveDirectoryProperty)(
                    &handle, propertyName));
 
    AuthUser user(handle);
 
    return user;
}
 
inline AuthUser AuthUser::createWithManualOptions(
        const char *userId, const char *ipAddress)
{
    blpapi_AuthUser_t *handle = NULL;
 
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthUser_createWithManualOptions)(
                    &handle, userId, ipAddress));
 
    AuthUser user(handle);
 
    return user;
}
 
inline const blpapi_AuthUser_t *AuthUser::handle() const { return d_handle_p; }
 
// ==============================
// class AuthApplication
// ==============================
 
inline AuthApplication::AuthApplication(const char *name)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthApplication_create)(&d_handle_p, name));
}
 
inline AuthApplication::AuthApplication(blpapi_AuthApplication_t *handle)
    : d_handle_p(handle)
{
}
 
inline AuthApplication::AuthApplication(const AuthApplication& app)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_AuthApplication_duplicate)(
            &d_handle_p, app.handle()));
}
 
inline AuthApplication::~AuthApplication()
{
    BLPAPI_CALL_UNCHECKED(blpapi_AuthApplication_destroy)(d_handle_p);
}
 
inline AuthApplication& AuthApplication::operator=(const AuthApplication& rhs)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_AuthApplication_copy)(
            d_handle_p, rhs.handle()));
 
    return *this;
}
 
inline const blpapi_AuthApplication_t *AuthApplication::handle() const
{
    return d_handle_p;
}
 
// ========================
// class AuthToken
// ========================
 
inline AuthToken::AuthToken(const char *tokenStr)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthToken_create)(&d_handle_p, tokenStr));
}
 
inline AuthToken::AuthToken(blpapi_AuthToken_t *handle)
    : d_handle_p(handle)
{
}
 
inline AuthToken::AuthToken(const AuthToken& token)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_AuthToken_duplicate)(
            &d_handle_p, token.handle()));
}
 
inline AuthToken::~AuthToken()
{
    BLPAPI_CALL_UNCHECKED(blpapi_AuthToken_destroy)(d_handle_p);
}
 
inline AuthToken& AuthToken::operator=(const AuthToken& rhs)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_AuthToken_copy)(d_handle_p, rhs.handle()));
 
    return *this;
}
 
inline const blpapi_AuthToken_t *AuthToken::handle() const
{
    return d_handle_p;
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_AUTHOPTIONS