blpapi_sessionoptions.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_SESSIONOPTIONS
#define INCLUDED_BLPAPI_SESSIONOPTIONS

 
#ifndef INCLUDED_BLPAPI_CALL
#include <blpapi_call.h>
#endif
 
#ifndef INCLUDED_BLPAPI_CORRELATIONID
#include <blpapi_correlationid.h>
#endif
 
#ifndef INCLUDED_BLPAPI_DEFS
#include <blpapi_defs.h>
#endif
 
#ifndef INCLUDED_BLPAPI_EXCEPTION
#include <blpapi_exception.h>
#endif
 
#ifndef INCLUDED_BLPAPI_STREAMPROXY
#include <blpapi_streamproxy.h>
#endif
 
#ifndef INCLUDED_BLPAPI_TLSOPTIONS
#include <blpapi_tlsoptions.h>
#endif
 
#ifndef INCLUDED_BLPAPI_TYPES
#include <blpapi_types.h>
#endif
 
#include <blpapi_authoptions.h>
#include <blpapi_error.h>
#include <blpapi_socks5config.h>
 
#include <stddef.h>
 
#ifdef __cplusplus
 
extern "C" {
#endif



BLPAPI_EXPORT
blpapi_SessionOptions_t *blpapi_SessionOptions_create(void);

BLPAPI_EXPORT
blpapi_SessionOptions_t *blpapi_SessionOptions_duplicate(
        const blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
void blpapi_SessionOptions_copy(
        blpapi_SessionOptions_t *lhs, const blpapi_SessionOptions_t *rhs);

BLPAPI_EXPORT
void blpapi_SessionOptions_destroy(blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_setServerHost(
        blpapi_SessionOptions_t *parameters, const char *serverHost);

BLPAPI_EXPORT
int blpapi_SessionOptions_setServerPort(
        blpapi_SessionOptions_t *parameters, unsigned short serverPort);

BLPAPI_EXPORT
int blpapi_SessionOptions_setServerAddress(blpapi_SessionOptions_t *parameters,
        const char *serverHost,
        unsigned short serverPort,
        size_t index);

BLPAPI_EXPORT
int blpapi_SessionOptions_setServerAddressWithProxy(
        blpapi_SessionOptions_t *parameters,
        const char *serverHost,
        unsigned short serverPort,
        const blpapi_Socks5Config_t *socks5Config,
        size_t index);

BLPAPI_EXPORT
int blpapi_SessionOptions_removeServerAddress(
        blpapi_SessionOptions_t *parameters, size_t index);

BLPAPI_EXPORT
int blpapi_SessionOptions_setConnectTimeout(
        blpapi_SessionOptions_t *parameters,
        unsigned int timeoutInMilliseconds);

BLPAPI_EXPORT
int blpapi_SessionOptions_setDefaultServices(
        blpapi_SessionOptions_t *parameters, const char *defaultServices);

BLPAPI_EXPORT
int blpapi_SessionOptions_setDefaultSubscriptionService(
        blpapi_SessionOptions_t *parameters, const char *serviceIdentifier);

BLPAPI_EXPORT
void blpapi_SessionOptions_setDefaultTopicPrefix(
        blpapi_SessionOptions_t *parameters, const char *prefix);

BLPAPI_EXPORT
void blpapi_SessionOptions_setAllowMultipleCorrelatorsPerMsg(
        blpapi_SessionOptions_t *parameters,
        int allowMultipleCorrelatorsPerMsg);

BLPAPI_EXPORT
void blpapi_SessionOptions_setClientMode(
        blpapi_SessionOptions_t *parameters, int clientMode);

BLPAPI_EXPORT
void blpapi_SessionOptions_setMaxPendingRequests(
        blpapi_SessionOptions_t *parameters, int maxPendingRequests);

BLPAPI_EXPORT
void blpapi_SessionOptions_setAutoRestartOnDisconnection(
        blpapi_SessionOptions_t *parameters, int autoRestart);

BLPAPI_EXPORT
void blpapi_SessionOptions_setAutoRestart(
        blpapi_SessionOptions_t *parameters, int autoRestart);
BLPAPI_EXPORT
int blpapi_SessionOptions_setSessionIdentityOptions(
        blpapi_SessionOptions_t *parameters,
        const blpapi_AuthOptions_t *authOptions,
        blpapi_CorrelationId_t *cid);

BLPAPI_EXPORT
void blpapi_SessionOptions_setAuthenticationOptions(
        blpapi_SessionOptions_t *parameters, const char *authOptions);

BLPAPI_EXPORT
void blpapi_SessionOptions_setNumStartAttempts(
        blpapi_SessionOptions_t *parameters, int numStartAttempts);

BLPAPI_EXPORT
void blpapi_SessionOptions_setMaxEventQueueSize(
        blpapi_SessionOptions_t *parameters, size_t maxEventQueueSize);

BLPAPI_EXPORT
int blpapi_SessionOptions_setSlowConsumerWarningHiWaterMark(
        blpapi_SessionOptions_t *parameters, float hiWaterMark);

BLPAPI_EXPORT
int blpapi_SessionOptions_setSlowConsumerWarningLoWaterMark(
        blpapi_SessionOptions_t *parameters, float loWaterMark);

BLPAPI_EXPORT
int blpapi_SessionOptions_setDefaultKeepAliveInactivityTime(
        blpapi_SessionOptions_t *parameters, int inactivityMsecs);

BLPAPI_EXPORT
int blpapi_SessionOptions_setDefaultKeepAliveResponseTimeout(
        blpapi_SessionOptions_t *parameters, int timeoutMsecs);

BLPAPI_EXPORT
int blpapi_SessionOptions_setKeepAliveEnabled(
        blpapi_SessionOptions_t *parameters, int isEnabled);

BLPAPI_EXPORT
void blpapi_SessionOptions_setRecordSubscriptionDataReceiveTimes(
        blpapi_SessionOptions_t *parameters, int shouldRecord);

BLPAPI_EXPORT
int blpapi_SessionOptions_setServiceCheckTimeout(
        blpapi_SessionOptions_t *paramaters, int timeoutMsecs);

BLPAPI_EXPORT
int blpapi_SessionOptions_setServiceDownloadTimeout(
        blpapi_SessionOptions_t *paramaters, int timeoutMsecs);

BLPAPI_EXPORT
void blpapi_SessionOptions_setTlsOptions(blpapi_SessionOptions_t *paramaters,
        const blpapi_TlsOptions_t *tlsOptions);

BLPAPI_EXPORT
int blpapi_SessionOptions_setFlushPublishedEventsTimeout(
        blpapi_SessionOptions_t *paramaters, int timeoutMsecs);

BLPAPI_EXPORT
int blpapi_SessionOptions_setBandwidthSaveModeDisabled(
        blpapi_SessionOptions_t *parameters, int disableBandwidthSaveMode);

BLPAPI_EXPORT
const char *blpapi_SessionOptions_serverHost(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
unsigned int blpapi_SessionOptions_serverPort(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_numServerAddresses(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_getServerAddress(blpapi_SessionOptions_t *parameters,
        const char **serverHost,
        unsigned short *serverPort,
        size_t index);

BLPAPI_EXPORT
int blpapi_SessionOptions_getServerAddressWithProxy(
        blpapi_SessionOptions_t *parameters,
        const char **serverHost,
        unsigned short *serverPort,
        const char **socks5Host,
        unsigned short *sock5Port,
        size_t index);

BLPAPI_EXPORT
unsigned int blpapi_SessionOptions_connectTimeout(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
const char *blpapi_SessionOptions_defaultServices(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
const char *blpapi_SessionOptions_defaultSubscriptionService(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
const char *blpapi_SessionOptions_defaultTopicPrefix(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_allowMultipleCorrelatorsPerMsg(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_clientMode(blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_maxPendingRequests(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_autoRestartOnDisconnection(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_autoRestart(blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
const char *blpapi_SessionOptions_authenticationOptions(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_numStartAttempts(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
size_t blpapi_SessionOptions_maxEventQueueSize(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
float blpapi_SessionOptions_slowConsumerWarningHiWaterMark(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
float blpapi_SessionOptions_slowConsumerWarningLoWaterMark(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_defaultKeepAliveInactivityTime(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_defaultKeepAliveResponseTimeout(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_keepAliveEnabled(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_recordSubscriptionDataReceiveTimes(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_serviceCheckTimeout(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_serviceDownloadTimeout(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_print(blpapi_SessionOptions_t *parameters,
        blpapi_StreamWriter_t streamWriter,
        void *stream,
        int indentLevel,
        int spacesPerLevel);

BLPAPI_EXPORT
int blpapi_SessionOptions_flushPublishedEventsTimeout(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_bandwidthSaveModeDisabled(
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_setApplicationIdentityKey(
        blpapi_SessionOptions_t *parameters,
        const char *applicationIdentityKey,
        size_t size);
BLPAPI_EXPORT
int blpapi_SessionOptions_applicationIdentityKey(
        const char **applicationIdentityKey,
        size_t *size,
        blpapi_SessionOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_SessionOptions_setSessionName(blpapi_SessionOptions_t *parameters,
        const char *sessionName,
        size_t size);

BLPAPI_EXPORT
int blpapi_SessionOptions_sessionName(const char **sessionName,
        size_t *size,
        blpapi_SessionOptions_t *parameters);

 
#ifdef __cplusplus
}
 
namespace BloombergLP {
namespace blpapi {

class SessionOptions {
 
    blpapi_SessionOptions_t *d_handle_p;
 
  public:
    /*
     * The possible options for how to connect to the API
     */
 
    enum ClientMode {
        AUTO = BLPAPI_CLIENTMODE_AUTO,
 
        DAPI = BLPAPI_CLIENTMODE_DAPI,
 
        SAPI = BLPAPI_CLIENTMODE_SAPI
    };
 
    SessionOptions();
 
    SessionOptions(const SessionOptions& original);
 
    ~SessionOptions();
 
    // MANIPULATORS
 
    SessionOptions& operator=(const SessionOptions& rhs);
 
    void setServerHost(const char *host);
 
    void setServerPort(unsigned short port);
 
    int setServerAddress(
            const char *serverHost, unsigned short serverPort, size_t index);
 
    int setServerAddress(const char *serverHost,
            unsigned short serverPort,
            const Socks5Config& socks5Config,
            size_t index);
 
    int removeServerAddress(size_t index);
 
    void setConnectTimeout(unsigned int timeoutMilliSeconds);
 
    void setDefaultServices(const char *defaultServices);
 
    void setDefaultSubscriptionService(const char *serviceIdentifier);
 
    void setDefaultTopicPrefix(const char *prefix);
 
    void setAllowMultipleCorrelatorsPerMsg(
            bool allowMultipleCorrelatorsPerMsg);
 
    void setClientMode(int clientMode);
 
    void setMaxPendingRequests(int maxPendingRequests);
 
    CorrelationId setSessionIdentityOptions(const AuthOptions& authOptions,
            const CorrelationId& correlationId = CorrelationId());
 
    void setAuthenticationOptions(const char *authOptions);
 
    void setNumStartAttempts(int numStartAttempts);
 
    void setAutoRestartOnDisconnection(bool autoRestart);
 
    void setMaxEventQueueSize(size_t eventQueueSize);
 
    void setSlowConsumerWarningHiWaterMark(float hiWaterMark);
 
    void setSlowConsumerWarningLoWaterMark(float loWaterMark);
 
    void setDefaultKeepAliveInactivityTime(int inactivityMsecs);
 
    void setDefaultKeepAliveResponseTimeout(int timeoutMsecs);
 
    void setKeepAliveEnabled(bool isEnabled);
 
    void setRecordSubscriptionDataReceiveTimes(bool shouldRecord);
 
    void setServiceCheckTimeout(int timeoutMsecs);
 
    void setServiceDownloadTimeout(int timeoutMsecs);
 
    void setTlsOptions(const TlsOptions& tlsOptions);
 
    void setFlushPublishedEventsTimeout(int timeoutMsecs);
 
    void setBandwidthSaveModeDisabled(bool isDisabled);
 
    void setApplicationIdentityKey(const std::string& applicationIdentityKey);
 
    void setSessionName(const std::string& sessionName);
 
    // ACCESSORS
    const char *serverHost() const;
 
    unsigned short serverPort() const;
 
    size_t numServerAddresses() const;
 
    int getServerAddress(const char **serverHost,
            unsigned short *serverPort,
            size_t index) const;
 
    int getServerAddress(const char **serverHost,
            unsigned short *serverPort,
            Socks5Config *socksConfig,
            size_t index) const;
 
    unsigned int connectTimeout() const;
 
    const char *defaultServices() const;
 
    const char *defaultSubscriptionService() const;
 
    const char *defaultTopicPrefix() const;
 
    bool allowMultipleCorrelatorsPerMsg() const;
 
    int clientMode() const;
 
    int maxPendingRequests() const;

    blpapi_SessionOptions_t *handle() const;
 
    bool autoRestartOnDisconnection() const;
 
    const char *authenticationOptions() const;
 
    int numStartAttempts() const;
 
    size_t maxEventQueueSize() const;
 
    float slowConsumerWarningHiWaterMark() const;
 
    float slowConsumerWarningLoWaterMark() const;
 
    int defaultKeepAliveInactivityTime() const;
 
    int defaultKeepAliveResponseTimeout() const;
 
    bool keepAliveEnabled() const;
 
    bool recordSubscriptionDataReceiveTimes() const;
 
    int serviceCheckTimeout() const;
 
    int serviceDownloadTimeout() const;
 
    int flushPublishedEventsTimeout() const;
 
    bool bandwidthSaveModeDisabled() const;
 
    std::string applicationIdentityKey();
 
    std::string sessionName();
 
    std::ostream& print(std::ostream& stream,
            int indentLevel = 0,
            int spacesPerLevel = 4) const;
};

 
// FREE OPERATORS
std::ostream& operator<<(
        std::ostream& stream, const SessionOptions& sessionOptions);
 
// ============================================================================
//                      INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// --------------------
// class SessionOptions
// --------------------
inline SessionOptions::SessionOptions()
{
    d_handle_p = blpapi_SessionOptions_create();
#if BLPAPI_COMPAT_33X
    blpapi_SessionOptions_setClientMode(
            d_handle_p, BLPAPI_CLIENTMODE_AUTO | BLPAPI_CLIENTMODE_COMPAT_33X);
#endif
}
 
inline SessionOptions::SessionOptions(const SessionOptions& options)
{
    d_handle_p = blpapi_SessionOptions_duplicate(options.handle());
}
 
inline SessionOptions::~SessionOptions()
{
    blpapi_SessionOptions_destroy(d_handle_p);
}
 
inline SessionOptions& SessionOptions::operator=(const SessionOptions& rhs)
{
    blpapi_SessionOptions_copy(this->handle(), rhs.handle());
    return *this;
}
 
inline void SessionOptions::setServerHost(const char *newServerHost)
{
    blpapi_SessionOptions_setServerHost(d_handle_p, newServerHost);
}
 
inline void SessionOptions::setServerPort(unsigned short newServerPort)
{
    blpapi_SessionOptions_setServerPort(d_handle_p, newServerPort);
}
 
inline int SessionOptions::setServerAddress(
        const char *serverHost, unsigned short serverPort, size_t index)
{
    return blpapi_SessionOptions_setServerAddress(
            d_handle_p, serverHost, serverPort, index);
}
 
inline int SessionOptions::setServerAddress(const char *serverHost,
        unsigned short serverPort,
        const Socks5Config& socks5Config,
        size_t index)
{
    return BLPAPI_CALL(blpapi_SessionOptions_setServerAddressWithProxy)(
            d_handle_p, serverHost, serverPort, socks5Config.impl(), index);
}
 
inline int SessionOptions::removeServerAddress(size_t index)
{
    return blpapi_SessionOptions_removeServerAddress(d_handle_p, index);
}
 
inline void SessionOptions::setConnectTimeout(unsigned int timeoutMilliSeconds)
{
    ExceptionUtil::throwOnError(blpapi_SessionOptions_setConnectTimeout(
            d_handle_p, timeoutMilliSeconds));
}
 
inline void SessionOptions::setDefaultServices(const char *newDefaultServices)
{
    blpapi_SessionOptions_setDefaultServices(d_handle_p, newDefaultServices);
}
 
inline void SessionOptions::setDefaultSubscriptionService(
        const char *serviceIdentifier)
{
    blpapi_SessionOptions_setDefaultSubscriptionService(
            d_handle_p, serviceIdentifier);
}
 
inline void SessionOptions::setDefaultTopicPrefix(const char *prefix)
{
    blpapi_SessionOptions_setDefaultTopicPrefix(d_handle_p, prefix);
}
 
inline void SessionOptions::setAllowMultipleCorrelatorsPerMsg(
        bool newAllowMultipleCorrelatorsPerMsg)
{
    blpapi_SessionOptions_setAllowMultipleCorrelatorsPerMsg(
            d_handle_p, newAllowMultipleCorrelatorsPerMsg);
}
 
inline void SessionOptions::setClientMode(int newClientMode)
{
#if BLPAPI_COMPAT_33X
    newClientMode |= BLPAPI_CLIENTMODE_COMPAT_33X;
#endif
 
    blpapi_SessionOptions_setClientMode(d_handle_p, newClientMode);
}
 
inline void SessionOptions::setMaxPendingRequests(int newMaxPendingRequests)
{
    blpapi_SessionOptions_setMaxPendingRequests(
            d_handle_p, newMaxPendingRequests);
}
 
inline void SessionOptions::setAutoRestartOnDisconnection(bool autoRestart)
{
    blpapi_SessionOptions_setAutoRestartOnDisconnection(
            d_handle_p, autoRestart ? 1 : 0);
}
 
inline CorrelationId SessionOptions::setSessionIdentityOptions(
        const AuthOptions& authOptions, const CorrelationId& cid)
{
    blpapi_CorrelationId_t cidHandle = cid.impl();
 
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_SessionOptions_setSessionIdentityOptions)(
                    d_handle_p, authOptions.handle(), &cidHandle));
 
    return CorrelationId(cidHandle);
}
 
inline void SessionOptions::setAuthenticationOptions(const char *authOptions)
{
    blpapi_SessionOptions_setAuthenticationOptions(d_handle_p, authOptions);
}
 
inline void SessionOptions::setNumStartAttempts(int newNumStartAttempts)
{
    blpapi_SessionOptions_setNumStartAttempts(d_handle_p, newNumStartAttempts);
}
 
inline void SessionOptions::setMaxEventQueueSize(size_t eventQueueSize)
{
    BLPAPI_CALL_SESSIONOPTIONS_SETMAXEVENTQUEUESIZE(
            d_handle_p, eventQueueSize);
}
 
inline void SessionOptions::setSlowConsumerWarningHiWaterMark(
        float hiWaterMark)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSIONOPTIONS_SETSLOWCONSUMERHIWATERMARK(
                    d_handle_p, hiWaterMark));
}
 
inline void SessionOptions::setSlowConsumerWarningLoWaterMark(
        float loWaterMark)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSIONOPTIONS_SETSLOWCONSUMERLOWATERMARK(
                    d_handle_p, loWaterMark));
}
 
inline void SessionOptions::setDefaultKeepAliveInactivityTime(
        int inactivityTime)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSIONOPTIONS_SETDEFAULTKEEPALIVEINACTIVITYTIME(
                    d_handle_p, inactivityTime));
}
 
inline void SessionOptions::setDefaultKeepAliveResponseTimeout(
        int responseTimeout)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSIONOPTIONS_SETDEFAULTKEEPALIVERESPONSETIMEOUT(
                    d_handle_p, responseTimeout));
}
 
inline void SessionOptions::setKeepAliveEnabled(bool isEnabled)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL_SESSIONOPTIONS_SETKEEPALIVEENABLED(
            d_handle_p, isEnabled));
}
 
inline void SessionOptions::setRecordSubscriptionDataReceiveTimes(
        bool shouldRecrod)
{
    BLPAPI_CALL_SESSIONOPTION_SETRECORDSUBSCRIPTIONDATARECEIVETIMES(
            d_handle_p, shouldRecrod);
}
 
inline void SessionOptions::setServiceCheckTimeout(int timeoutMsecs)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_SessionOptions_setServiceCheckTimeout)(
                    d_handle_p, timeoutMsecs));
}
 
inline void SessionOptions::setServiceDownloadTimeout(int timeoutMsecs)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_SessionOptions_setServiceDownloadTimeout)(
                    d_handle_p, timeoutMsecs));
}
 
inline void SessionOptions::setTlsOptions(const TlsOptions& tlsOptions)
{
    BLPAPI_CALL(blpapi_SessionOptions_setTlsOptions)
    (d_handle_p, tlsOptions.handle());
}
 
inline void SessionOptions::setFlushPublishedEventsTimeout(int timeoutMsecs)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_SessionOptions_setFlushPublishedEventsTimeout)(
                    d_handle_p, timeoutMsecs));
}
 
inline void SessionOptions::setBandwidthSaveModeDisabled(bool isDisabled)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SESSIONOPTIONS_SETBANDWIDTHSAVEMODEDISABLED(
                    d_handle_p, isDisabled));
}
 
inline const char *SessionOptions::serverHost() const
{
    return blpapi_SessionOptions_serverHost(d_handle_p);
}
 
inline unsigned short SessionOptions::serverPort() const
{
    return static_cast<unsigned short>(
            blpapi_SessionOptions_serverPort(d_handle_p));
}
 
inline size_t SessionOptions::numServerAddresses() const
{
    return static_cast<size_t>(
            blpapi_SessionOptions_numServerAddresses(d_handle_p));
}
 
inline int SessionOptions::getServerAddress(const char **serverHostOut,
        unsigned short *serverPortOut,
        size_t index) const
{
    return blpapi_SessionOptions_getServerAddress(
            d_handle_p, serverHostOut, serverPortOut, index);
}
 
inline int SessionOptions::getServerAddress(const char **serverHostOut,
        unsigned short *serverPortOut,
        Socks5Config *socksConfig,
        size_t index) const
{
    const char *socks5ConfigHost = 0;
    unsigned short socks5ConfigPort = 0;
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_SessionOptions_getServerAddressWithProxy)(d_handle_p,
            serverHostOut,
            serverPortOut,
            &socks5ConfigHost,
            &socks5ConfigPort,
            index));
 
    if (socks5ConfigHost) {
        *socksConfig = Socks5Config(socks5ConfigHost, socks5ConfigPort);
    }
 
    return 0;
}
 
inline unsigned int SessionOptions::connectTimeout() const
{
    return blpapi_SessionOptions_connectTimeout(d_handle_p);
}
 
inline const char *SessionOptions::defaultServices() const
{
    return blpapi_SessionOptions_defaultServices(d_handle_p);
}
 
inline const char *SessionOptions::defaultSubscriptionService() const
{
    return blpapi_SessionOptions_defaultSubscriptionService(d_handle_p);
}
 
inline const char *SessionOptions::defaultTopicPrefix() const
{
    return blpapi_SessionOptions_defaultTopicPrefix(d_handle_p);
}
 
inline bool SessionOptions::allowMultipleCorrelatorsPerMsg() const
{
    return blpapi_SessionOptions_allowMultipleCorrelatorsPerMsg(d_handle_p)
            ? true
            : false;
}
 
inline int SessionOptions::clientMode() const
{
    return blpapi_SessionOptions_clientMode(d_handle_p);
}
 
inline int SessionOptions::maxPendingRequests() const
{
    return blpapi_SessionOptions_maxPendingRequests(d_handle_p);
}
 
inline bool SessionOptions::autoRestartOnDisconnection() const
{
    return blpapi_SessionOptions_autoRestartOnDisconnection(d_handle_p) != 0;
}
 
inline const char *SessionOptions::authenticationOptions() const
{
    return blpapi_SessionOptions_authenticationOptions(d_handle_p);
}
 
inline int SessionOptions::numStartAttempts() const
{
    return blpapi_SessionOptions_numStartAttempts(d_handle_p);
}
 
inline size_t SessionOptions::maxEventQueueSize() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_MAXEVENTQUEUESIZE(d_handle_p);
}
 
inline float SessionOptions::slowConsumerWarningHiWaterMark() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_SLOWCONSUMERHIWATERMARK(d_handle_p);
}
 
inline float SessionOptions::slowConsumerWarningLoWaterMark() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_SLOWCONSUMERLOWATERMARK(d_handle_p);
}
 
inline int SessionOptions::defaultKeepAliveInactivityTime() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_DEFAULTKEEPALIVEINACTIVITYTIME(
            d_handle_p);
}
 
inline int SessionOptions::defaultKeepAliveResponseTimeout() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_DEFAULTKEEPALIVERESPONSETIMEOUT(
            d_handle_p);
}
 
inline bool SessionOptions::keepAliveEnabled() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_KEEPALIVEENABLED(d_handle_p) != 0
            ? true
            : false;
}
 
inline bool SessionOptions::recordSubscriptionDataReceiveTimes() const
{
    return BLPAPI_CALL_SESSIONOPTION_RECORDSUBSCRIPTIONDATARECEIVETIMES(
                   d_handle_p)
            ? true
            : false;
}
 
inline int SessionOptions::serviceCheckTimeout() const
{
    return BLPAPI_CALL(blpapi_SessionOptions_serviceCheckTimeout)(d_handle_p);
}
 
inline int SessionOptions::serviceDownloadTimeout() const
{
    return BLPAPI_CALL(blpapi_SessionOptions_serviceDownloadTimeout)(
            d_handle_p);
}
 
inline int SessionOptions::flushPublishedEventsTimeout() const
{
    return BLPAPI_CALL(blpapi_SessionOptions_flushPublishedEventsTimeout)(
            d_handle_p);
}
 
inline bool SessionOptions::bandwidthSaveModeDisabled() const
{
    return BLPAPI_CALL_SESSIONOPTIONS_BANDWIDTHSAVEMODEDISABLED(d_handle_p)
                    != 0
            ? true
            : false;
}
 
inline void SessionOptions::setApplicationIdentityKey(
        const std::string& applicationIdentityKey)
{
    ExceptionUtil::throwOnError(BLPAPI_CALL(
            blpapi_SessionOptions_setApplicationIdentityKey)(d_handle_p,
            applicationIdentityKey.data(),
            static_cast<int>(applicationIdentityKey.size())));
}
 
inline std::string SessionOptions::applicationIdentityKey()
{
    const char *aik;
    size_t size;
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_SessionOptions_applicationIdentityKey)(
                    &aik, &size, d_handle_p));
    return std::string(aik, size);
}
 
inline void SessionOptions::setSessionName(const std::string& sessionName)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL(blpapi_SessionOptions_setSessionName)(
                    d_handle_p, sessionName.data(), sessionName.size()));
}
 
inline std::string SessionOptions::sessionName()
{
    const char *sessionName = nullptr;
    size_t size = 0;
    ExceptionUtil::throwOnError(BLPAPI_CALL(blpapi_SessionOptions_sessionName)(
            &sessionName, &size, d_handle_p));
    return std::string(sessionName, size);
}

inline blpapi_SessionOptions_t *SessionOptions::handle() const
{
    return d_handle_p;
}
 
inline std::ostream& SessionOptions::print(
        std::ostream& stream, int indentLevel, int spacesPerLevel) const
{
    if (BLPAPI_CALL_AVAILABLE(blpapi_SessionOptions_print)) {
        BLPAPI_CALL(blpapi_SessionOptions_print)
        (d_handle_p,
                StreamProxyOstream::writeToStream,
                &stream,
                indentLevel,
                spacesPerLevel);
    }
    return stream;
}
 
inline std::ostream& operator<<(
        std::ostream& stream, const SessionOptions& sessionOptions)
{
    return sessionOptions.print(stream, 0, -1);
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_SESSIONOPTIONS