blpapi_providersession.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_PROVIDERSESSION
#define INCLUDED_BLPAPI_PROVIDERSESSION

 
#ifndef INCLUDED_BLPAPI_ABSTRACTSESSION
#include <blpapi_abstractsession.h>
#endif
 
#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_EVENT
#include <blpapi_event.h>
#endif
 
#ifndef INCLUDED_BLPAPI_EVENTDISPATCHER
#include <blpapi_eventdispatcher.h>
#endif
 
#ifndef INCLUDED_BLPAPI_IDENTITY
#include <blpapi_identity.h>
#endif
 
#ifndef INCLUDED_BLPAPI_REQUEST
#include <blpapi_request.h>
#endif
 
#ifndef INCLUDED_BLPAPI_RESOLUTIONLIST
#include <blpapi_resolutionlist.h>
#endif
 
#ifndef INCLUDED_BLPAPI_SERVICE
#include <blpapi_service.h>
#endif
 
#ifndef INCLUDED_BLPAPI_SESSIONOPTIONS
#include <blpapi_sessionoptions.h>
#endif
 
#ifndef INCLUDED_BLPAPI_SUBSCRIPTIONLIST
#include <blpapi_subscriptionlist.h>
#endif
 
#ifndef INCLUDED_BLPAPI_TOPIC
#include <blpapi_topic.h>
#endif
 
#ifndef INCLUDED_BLPAPI_TOPICLIST
#include <blpapi_topiclist.h>
#endif
 
#ifndef INCLUDED_BLPAPI_TYPES
#include <blpapi_types.h>
#endif
 
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif


 
struct blpapi_ServiceRegistrationOptions;
typedef struct blpapi_ServiceRegistrationOptions
        blpapi_ServiceRegistrationOptions_t;

typedef void (*blpapi_ProviderEventHandler_t)(blpapi_Event_t *event,
        blpapi_ProviderSession_t *session,
        void *userData);

BLPAPI_EXPORT
blpapi_ProviderSession_t *blpapi_ProviderSession_create(
        blpapi_SessionOptions_t *parameters,
        blpapi_ProviderEventHandler_t handler,
        blpapi_EventDispatcher_t *dispatcher,
        void *userData);

BLPAPI_EXPORT
void blpapi_ProviderSession_destroy(blpapi_ProviderSession_t *session);

BLPAPI_EXPORT
int blpapi_ProviderSession_start(blpapi_ProviderSession_t *session);

BLPAPI_EXPORT
int blpapi_ProviderSession_startAsync(blpapi_ProviderSession_t *session);

BLPAPI_EXPORT
int blpapi_ProviderSession_stop(blpapi_ProviderSession_t *session);

BLPAPI_EXPORT
int blpapi_ProviderSession_stopAsync(blpapi_ProviderSession_t *session);

BLPAPI_EXPORT
int blpapi_ProviderSession_nextEvent(blpapi_ProviderSession_t *session,
        blpapi_Event_t **eventPointer,
        unsigned int timeoutInMilliseconds);

BLPAPI_EXPORT
int blpapi_ProviderSession_tryNextEvent(
        blpapi_ProviderSession_t *session, blpapi_Event_t **eventPointer);

BLPAPI_EXPORT
int blpapi_ProviderSession_registerService(blpapi_ProviderSession_t *session,
        const char *serviceName,
        const blpapi_Identity_t *identity,
        blpapi_ServiceRegistrationOptions_t *registrationOptions);

BLPAPI_EXPORT
int blpapi_ProviderSession_activateSubServiceCodeRange(
        blpapi_ProviderSession_t *session,
        const char *serviceName,
        int begin,
        int end,
        int priority);

BLPAPI_EXPORT
int blpapi_ProviderSession_deactivateSubServiceCodeRange(
        blpapi_ProviderSession_t *session,
        const char *serviceName,
        int begin,
        int end);

BLPAPI_EXPORT
int blpapi_ProviderSession_registerServiceAsync(
        blpapi_ProviderSession_t *session,
        const char *serviceName,
        const blpapi_Identity_t *identity,
        blpapi_CorrelationId_t *correlationId,
        blpapi_ServiceRegistrationOptions_t *registrationOptions);

BLPAPI_EXPORT
int blpapi_ProviderSession_deregisterService(
        blpapi_ProviderSession_t *session, const char *serviceName);

BLPAPI_EXPORT
int blpapi_ProviderSession_resolve(blpapi_ProviderSession_t *session,
        blpapi_ResolutionList_t *resolutionList,
        int resolveMode,
        const blpapi_Identity_t *identity);

BLPAPI_EXPORT
int blpapi_ProviderSession_resolveAsync(blpapi_ProviderSession_t *session,
        const blpapi_ResolutionList_t *resolutionList,
        int resolveMode,
        const blpapi_Identity_t *identity);

BLPAPI_EXPORT
int blpapi_ProviderSession_createTopics(blpapi_ProviderSession_t *session,
        blpapi_TopicList_t *topicList,
        int resolveMode,
        const blpapi_Identity_t *identity);

BLPAPI_EXPORT
int blpapi_ProviderSession_createTopicsAsync(blpapi_ProviderSession_t *session,
        const blpapi_TopicList_t *topicList,
        int resolveMode,
        const blpapi_Identity_t *identity);

BLPAPI_EXPORT
int blpapi_ProviderSession_getTopic(blpapi_ProviderSession_t *session,
        const blpapi_Message_t *message,
        blpapi_Topic_t **topic);

BLPAPI_EXPORT
int blpapi_ProviderSession_createTopic(blpapi_ProviderSession_t *session,
        const blpapi_Message_t *message,
        blpapi_Topic_t **topic);

BLPAPI_EXPORT
int blpapi_ProviderSession_createServiceStatusTopic(
        blpapi_ProviderSession_t *session,
        const blpapi_Service_t *service,
        blpapi_Topic_t **topic);

BLPAPI_EXPORT
int blpapi_ProviderSession_deleteTopics(blpapi_ProviderSession_t *session,
        const blpapi_Topic_t **topics,
        size_t numTopics);

BLPAPI_EXPORT
int blpapi_ProviderSession_terminateSubscriptionsOnTopics(
        blpapi_ProviderSession_t *session,
        const blpapi_Topic_t **topics,
        size_t numTopics,
        const char *message);

BLPAPI_EXPORT
int blpapi_ProviderSession_publish(
        blpapi_ProviderSession_t *session, blpapi_Event_t *event);

BLPAPI_EXPORT
int blpapi_ProviderSession_sendResponse(blpapi_ProviderSession_t *session,
        blpapi_Event_t *event,
        int isPartialResponse);

BLPAPI_EXPORT
blpapi_AbstractSession_t *blpapi_ProviderSession_getAbstractSession(
        blpapi_ProviderSession_t *session);

BLPAPI_EXPORT
int blpapi_ProviderSession_flushPublishedEvents(
        blpapi_ProviderSession_t *session, int *allFlushed, int timeoutMsecs);
 
// ServiceRegistrationOptions

BLPAPI_EXPORT
blpapi_ServiceRegistrationOptions_t *blpapi_ServiceRegistrationOptions_create(
        void);

BLPAPI_EXPORT
blpapi_ServiceRegistrationOptions_t *
blpapi_ServiceRegistrationOptions_duplicate(
        const blpapi_ServiceRegistrationOptions_t *parameters);

BLPAPI_EXPORT
void blpapi_ServiceRegistrationOptions_destroy(
        blpapi_ServiceRegistrationOptions_t *parameters);

BLPAPI_EXPORT
void blpapi_ServiceRegistrationOptions_copy(
        blpapi_ServiceRegistrationOptions_t *lhs,
        const blpapi_ServiceRegistrationOptions_t *rhs);
 
// SUBSERVICE CODES
BLPAPI_EXPORT
int blpapi_ServiceRegistrationOptions_addActiveSubServiceCodeRange(
        blpapi_ServiceRegistrationOptions_t *parameters,
        int start,
        int end,
        int priority);

BLPAPI_EXPORT
void blpapi_ServiceRegistrationOptions_removeAllActiveSubServiceCodeRanges(
        blpapi_ServiceRegistrationOptions_t *parameters);

BLPAPI_EXPORT
void blpapi_ServiceRegistrationOptions_setGroupId(
        blpapi_ServiceRegistrationOptions_t *parameters,
        const char *groupId,
        unsigned int groupIdLength);

BLPAPI_EXPORT
int blpapi_ServiceRegistrationOptions_setServicePriority(
        blpapi_ServiceRegistrationOptions_t *parameters, int priority);

BLPAPI_EXPORT
void blpapi_ServiceRegistrationOptions_setPartsToRegister(
        blpapi_ServiceRegistrationOptions_t *parameters, int parts);

BLPAPI_EXPORT
int blpapi_ServiceRegistrationOptions_getGroupId(
        blpapi_ServiceRegistrationOptions_t *parameters,
        char *groupdIdBuffer,
        int *groupIdLength);

BLPAPI_EXPORT
int blpapi_ServiceRegistrationOptions_getServicePriority(
        blpapi_ServiceRegistrationOptions_t *parameters);

BLPAPI_EXPORT
int blpapi_ServiceRegistrationOptions_getPartsToRegister(
        blpapi_ServiceRegistrationOptions_t *parameters);

 
#ifdef __cplusplus
}
 
#include <cassert>
 
namespace BloombergLP {
namespace blpapi {

extern "C" inline void blpapi_providerEventHandlerAdapter(
        blpapi_Event_t *event,
        blpapi_ProviderSession_t *session,
        void *userData);
 
class ProviderSession;
// ==========================
// class ProviderEventHandler
// ==========================
 
class ProviderEventHandler {
  public:
    virtual ~ProviderEventHandler() { }
 
    virtual bool processEvent(const Event& event, ProviderSession *session)
            = 0;
};

class ServiceRegistrationOptions {
 
    blpapi_ServiceRegistrationOptions_t *d_handle_p;
 
  public:
    enum ServiceRegistrationPriority {
        PRIORITY_LOW = BLPAPI_SERVICEREGISTRATIONOPTIONS_PRIORITY_LOW,
        PRIORITY_MEDIUM = BLPAPI_SERVICEREGISTRATIONOPTIONS_PRIORITY_MEDIUM,
        PRIORITY_HIGH = BLPAPI_SERVICEREGISTRATIONOPTIONS_PRIORITY_HIGH
    };

    enum RegistrationParts {
 
        PART_PUBLISHING = BLPAPI_REGISTRATIONPARTS_PUBLISHING,
 
        PART_OPERATIONS = BLPAPI_REGISTRATIONPARTS_OPERATIONS,
 
        PART_SUBSCRIBER_RESOLUTION
        = BLPAPI_REGISTRATIONPARTS_SUBSCRIBER_RESOLUTION,
 
        PART_PUBLISHER_RESOLUTION
        = BLPAPI_REGISTRATIONPARTS_PUBLISHER_RESOLUTION,
 
        PART_DEFAULT = BLPAPI_REGISTRATIONPARTS_DEFAULT
    };
 
    ServiceRegistrationOptions();
 
    ServiceRegistrationOptions(const ServiceRegistrationOptions& original);
 
    ~ServiceRegistrationOptions();
 
    ServiceRegistrationOptions& operator=(
            const ServiceRegistrationOptions& rhs);
 
    void setGroupId(const char *groupId, unsigned int groupIdLength);
 
    int setServicePriority(int priority);
 
    void setPartsToRegister(int parts);
 
    void addActiveSubServiceCodeRange(int begin, int end, int priority);
 
    void removeAllActiveSubServiceCodeRanges();
 
    int getGroupId(char *groupId, int *groupIdLength) const;
 
    int getServicePriority() const;
 
    int getPartsToRegister() const;

    blpapi_ServiceRegistrationOptions_t *handle() const;
};

class ProviderSession : public AbstractSession {
 
  public:
    typedef ::BloombergLP::blpapi::ProviderEventHandler EventHandler;
 
  private:
    blpapi_ProviderSession_t *d_handle_p;
    EventHandler *d_eventHandler_p;
 
  private:
    friend void blpapi_providerEventHandlerAdapter(blpapi_Event_t *event,
            blpapi_ProviderSession_t *session,
            void *userData);
 
    void dispatchEvent(const Event& event);
 
  private:
    // NOT IMPLEMENTED
    ProviderSession(const ProviderSession&);
    ProviderSession& operator=(const ProviderSession&);
 
  public:
    enum ResolveMode {
        AUTO_REGISTER_SERVICES = BLPAPI_RESOLVEMODE_AUTO_REGISTER_SERVICES,
        DONT_REGISTER_SERVICES = BLPAPI_RESOLVEMODE_DONT_REGISTER_SERVICES
    };
 
    explicit ProviderSession(const SessionOptions& options = SessionOptions(),
            EventHandler *eventHandler = 0,
            EventDispatcher *eventDispatcher = 0);

    explicit ProviderSession(blpapi_ProviderSession_t *handle);
 
    virtual ~ProviderSession();
 
    // MANIPULATORS
    virtual bool start();
 
    virtual bool startAsync();
 
    virtual void stop();
 
    virtual void stopAsync();
 
    virtual Event nextEvent(int timeout = 0);
 
    virtual int tryNextEvent(Event *event);
 
    virtual bool registerService(const char *serviceName,
            const Identity& providerIdentity = Identity(),
            const ServiceRegistrationOptions& registrationOptions
            = ServiceRegistrationOptions());
 
    virtual void activateSubServiceCodeRange(
            const char *serviceName, int begin, int end, int priority);
 
    virtual void deactivateSubServiceCodeRange(
            const char *serviceName, int begin, int end);
 
    virtual CorrelationId registerServiceAsync(const char *serviceName,
            const Identity& providerIdentity = Identity(),
            const CorrelationId& correlationId = CorrelationId(),
            const ServiceRegistrationOptions& registrationOptions
            = ServiceRegistrationOptions());
 
    virtual bool deregisterService(const char *serviceName);
 
    virtual void resolve(ResolutionList *resolutionList,
            ResolveMode resolveMode = DONT_REGISTER_SERVICES,
            const Identity& providerIdentity = Identity());
 
    virtual void resolveAsync(const ResolutionList& resolutionList,
            ResolveMode resolveMode = DONT_REGISTER_SERVICES,
            const Identity& providerIdentity = Identity());
 
    virtual Topic getTopic(const Message& message);
 
    virtual Topic createServiceStatusTopic(const Service& service);
 
    virtual void publish(const Event& event);
 
    virtual void sendResponse(
            const Event& event, bool isPartialResponse = false);
 
    virtual void createTopics(TopicList *topicList,
            ResolveMode resolveMode = DONT_REGISTER_SERVICES,
            const Identity& providerIdentity = Identity());
 
    virtual void createTopicsAsync(const TopicList& topicList,
            ResolveMode resolveMode = DONT_REGISTER_SERVICES,
            const Identity& providerIdentity = Identity());
 
    virtual void deleteTopic(const Topic& topic);
 
    virtual void deleteTopics(const std::vector<Topic>& topics);
 
    virtual void deleteTopics(const Topic *topics, size_t numTopics);
 
    virtual void terminateSubscriptionsOnTopic(
            const Topic& topic, const char *message = 0);
 
    virtual void terminateSubscriptionsOnTopics(
            const std::vector<Topic>& topics, const char *message = 0);
 
    virtual void terminateSubscriptionsOnTopics(
            const Topic *topics, size_t numTopics, const char *message = 0);
 
    virtual bool flushPublishedEvents(int timeoutMsecs);

    blpapi_ProviderSession_t *handle() const;

    virtual Topic createTopic(const Message& message);
};

 
namespace util {

 
constexpr const char *to_string(
        ServiceRegistrationOptions::ServiceRegistrationPriority priority);
 
constexpr const char *to_string(
        ServiceRegistrationOptions::RegistrationParts parts);
 
constexpr const char *to_string(ProviderSession::ResolveMode resolveMode);

 
} // close namespace util
 
//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================
 
// ---------------------
// class ProviderSession
// ---------------------
 
inline ProviderSession::ProviderSession(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_ProviderSession_create(parameters.handle(),
            handler ? &blpapi_providerEventHandlerAdapter : 0,
            dispatcher ? dispatcher->impl() : 0,
            this);
    initAbstractSessionHandle(
            blpapi_ProviderSession_getAbstractSession(d_handle_p));
}

inline ProviderSession::ProviderSession(blpapi_ProviderSession_t *newHandle)
    : d_handle_p(newHandle)
{
    initAbstractSessionHandle(
            blpapi_ProviderSession_getAbstractSession(d_handle_p));
}
 
inline ProviderSession::~ProviderSession()
{
    blpapi_ProviderSession_destroy(d_handle_p);
}
 
inline bool ProviderSession::start()
{
    return blpapi_ProviderSession_start(d_handle_p) ? false : true;
}
 
inline bool ProviderSession::startAsync()
{
    return blpapi_ProviderSession_startAsync(d_handle_p) ? false : true;
}
 
inline void ProviderSession::stop()
{
    blpapi_ProviderSession_stop(d_handle_p);
}
 
inline void ProviderSession::stopAsync()
{
    blpapi_ProviderSession_stopAsync(d_handle_p);
}
 
inline Event ProviderSession::nextEvent(int timeout)
{
    if (timeout < 0) {
        throw InvalidArgumentException("Timeout must be >= 0.");
    }
 
    blpapi_Event_t *event = 0;
    ExceptionUtil::throwOnError(blpapi_ProviderSession_nextEvent(
            d_handle_p, &event, static_cast<unsigned>(timeout)));
    return Event(event);
}
 
inline int ProviderSession::tryNextEvent(Event *event)
{
    assert(event);
 
    blpapi_Event_t *impl = 0;
    int ret = blpapi_ProviderSession_tryNextEvent(d_handle_p, &impl);
    if (0 == ret) {
        *event = Event(impl);
    }
    return ret;
}
 
inline bool ProviderSession::registerService(const char *serviceName,
        const Identity& identity,
        const ServiceRegistrationOptions& registrationOptions)
{
    return blpapi_ProviderSession_registerService(d_handle_p,
                   serviceName,
                   identity.handle(),
                   registrationOptions.handle())
            ? false
            : true;
}
 
inline void ProviderSession::activateSubServiceCodeRange(
        const char *serviceName, int begin, int end, int priority)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_PROVIDERSESSION_ACTIVATESUBSERVICECODERANGE(
                    d_handle_p, serviceName, begin, end, priority));
}
 
inline void ProviderSession::deactivateSubServiceCodeRange(
        const char *serviceName, int begin, int end)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_PROVIDERSESSION_DEACTIVATESUBSERVICECODERANGE(
                    d_handle_p, serviceName, begin, end));
}
 
inline CorrelationId ProviderSession::registerServiceAsync(
        const char *serviceName,
        const Identity& identity,
        const CorrelationId& correlationId,
        const ServiceRegistrationOptions& registrationOptions)
{
    blpapi_CorrelationId_t retv = correlationId.impl();
    ExceptionUtil::throwOnError(
            blpapi_ProviderSession_registerServiceAsync(d_handle_p,
                    serviceName,
                    identity.handle(),
                    &retv,
                    registrationOptions.handle()));
 
    return CorrelationId(retv);
}
 
inline bool ProviderSession::deregisterService(const char *serviceName)
{
    return BLPAPI_CALL_PROVIDERSESSION_DEREGISTERSERVICE(
                   d_handle_p, serviceName)
                    == 0
            ? true
            : false;
}
 
inline void ProviderSession::resolve(ResolutionList *resolutionList,
        ResolveMode resolveMode,
        const Identity& identity)
{
    assert(resolutionList);
 
    ExceptionUtil::throwOnError(blpapi_ProviderSession_resolve(d_handle_p,
            resolutionList->impl(),
            resolveMode,
            identity.handle()));
    return;
}
 
inline void ProviderSession::resolveAsync(const ResolutionList& resolutionList,
        ResolveMode resolveMode,
        const Identity& identity)
{
    ExceptionUtil::throwOnError(blpapi_ProviderSession_resolveAsync(d_handle_p,
            resolutionList.impl(),
            resolveMode,
            identity.handle()));
    return;
}
 
inline Topic ProviderSession::createTopic(const Message& message)
{
    blpapi_Topic_t *topic = 0;
    ExceptionUtil::throwOnError(blpapi_ProviderSession_createTopic(
            d_handle_p, message.impl(), &topic));
 
    return Topic(topic);
}
 
inline Topic ProviderSession::getTopic(const Message& message)
{
    blpapi_Topic_t *topic = 0;
    ExceptionUtil::throwOnError(blpapi_ProviderSession_getTopic(
            d_handle_p, message.impl(), &topic));
 
    return Topic(topic);
}
 
inline Topic ProviderSession::createServiceStatusTopic(const Service& service)
{
    blpapi_Topic_t *topic = 0;
    ExceptionUtil::throwOnError(
            blpapi_ProviderSession_createServiceStatusTopic(
                    d_handle_p, service.handle(), &topic));
 
    return Topic(topic);
}
 
inline void ProviderSession::createTopics(TopicList *topicList,
        ResolveMode resolveMode,
        const Identity& identity)
{
    assert(topicList);
 
    ExceptionUtil::throwOnError(blpapi_ProviderSession_createTopics(
            d_handle_p, topicList->impl(), resolveMode, identity.handle()));
    return;
}
 
inline void ProviderSession::createTopicsAsync(const TopicList& topicList,
        ResolveMode resolveMode,
        const Identity& identity)
{
    ExceptionUtil::throwOnError(blpapi_ProviderSession_createTopicsAsync(
            d_handle_p, topicList.impl(), resolveMode, identity.handle()));
    return;
}
 
inline void ProviderSession::deleteTopic(const Topic& topic)
{
    const blpapi_Topic_t *topicImpl = topic.impl();
    ExceptionUtil::throwOnError(BLPAPI_CALL_PROVIDERSESSION_DELETETOPICS(
            d_handle_p, &topicImpl, 1));
}
 
inline void ProviderSession::deleteTopics(const std::vector<Topic>& topics)
{
    if (topics.size() == 0) {
        return;
    }
    std::vector<const blpapi_Topic_t *> topicImplList;
    topicImplList.reserve(topics.size());
    for (std::vector<Topic>::const_iterator it = topics.begin();
            it != topics.end();
            ++it) {
        topicImplList.push_back(it->impl());
    }
    ExceptionUtil::throwOnError(BLPAPI_CALL_PROVIDERSESSION_DELETETOPICS(
            d_handle_p, &topicImplList[0], topicImplList.size()));
}
 
inline void ProviderSession::deleteTopics(
        const Topic *topics, size_t numTopics)
{
    if (numTopics == 0) {
        return;
    }
 
    assert(topics);
 
    std::vector<const blpapi_Topic_t *> topicImplList;
    topicImplList.reserve(numTopics);
    for (size_t i = 0; i < numTopics; ++i) {
        topicImplList.push_back(topics[i].impl());
    }
    ExceptionUtil::throwOnError(BLPAPI_CALL_PROVIDERSESSION_DELETETOPICS(
            d_handle_p, &topicImplList[0], topicImplList.size()));
}
 
inline void ProviderSession::terminateSubscriptionsOnTopic(
        const Topic& topic, const char *message)
{
    const blpapi_Topic_t *topicImpl = topic.impl();
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_PROVIDERSESSION_TERMINATESUBSCRIPTIONSONTOPICS(
                    d_handle_p, &topicImpl, 1, message));
}
 
inline void ProviderSession::terminateSubscriptionsOnTopics(
        const std::vector<Topic>& topics, const char *message)
{
    if (topics.empty()) {
        return;
    }
    terminateSubscriptionsOnTopics(&topics.front(), topics.size(), message);
}
 
inline void ProviderSession::terminateSubscriptionsOnTopics(
        const Topic *topics, size_t numTopics, const char *message)
{
    if (numTopics == 0) {
        return;
    }
 
    assert(topics);
 
    std::vector<const blpapi_Topic_t *> topicImplList;
    topicImplList.reserve(numTopics);
    for (size_t i = 0; i < numTopics; ++i) {
        topicImplList.push_back(topics[i].impl());
    }
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_PROVIDERSESSION_TERMINATESUBSCRIPTIONSONTOPICS(
                    d_handle_p,
                    &topicImplList[0],
                    topicImplList.size(),
                    message));
}
 
inline void ProviderSession::publish(const Event& event)
{
    ExceptionUtil::throwOnError(
            blpapi_ProviderSession_publish(d_handle_p, event.impl()));
    return;
}
 
inline void ProviderSession::sendResponse(
        const Event& event, bool isPartialResponse)
{
    ExceptionUtil::throwOnError(blpapi_ProviderSession_sendResponse(
            d_handle_p, event.impl(), isPartialResponse));
    return;
}

inline blpapi_ProviderSession_t *ProviderSession::handle() const
{
    return d_handle_p;
}
 
inline void ProviderSession::dispatchEvent(const Event& event)
{
    assert(d_eventHandler_p);
 
    d_eventHandler_p->processEvent(event, this);
}
 
inline bool ProviderSession::flushPublishedEvents(int timeoutMsecs)
{
    int allFlushed = 0;
    int rc = BLPAPI_CALL(blpapi_ProviderSession_flushPublishedEvents)(
            d_handle_p, &allFlushed, timeoutMsecs);
    if (rc != 0) {
        ExceptionUtil::throwOnError(rc);
    }
    return allFlushed ? true : false;
}
 
// --------------------------------
// class ServiceRegistrationOptions
// --------------------------------
 
inline ServiceRegistrationOptions::ServiceRegistrationOptions()
{
    d_handle_p = blpapi_ServiceRegistrationOptions_create();
}
 
inline ServiceRegistrationOptions::ServiceRegistrationOptions(
        const ServiceRegistrationOptions& original)
{
    d_handle_p
            = blpapi_ServiceRegistrationOptions_duplicate(original.handle());
}
 
inline ServiceRegistrationOptions::~ServiceRegistrationOptions()
{
    blpapi_ServiceRegistrationOptions_destroy(d_handle_p);
}
 
inline ServiceRegistrationOptions& ServiceRegistrationOptions::operator=(
        const ServiceRegistrationOptions& rhs)
{
    blpapi_ServiceRegistrationOptions_copy(this->handle(), rhs.handle());
    return *this;
}
 
// SUBSERVICE CODES
inline void ServiceRegistrationOptions::addActiveSubServiceCodeRange(
        int begin, int end, int priority)
{
    ExceptionUtil::throwOnError(
            BLPAPI_CALL_SERVICEREGISTRATIONOPTIONS_ADDACTIVATESUBSERVICECODERANGE(
                    d_handle_p, begin, end, priority));
}
 
inline void ServiceRegistrationOptions::removeAllActiveSubServiceCodeRanges()
{
    BLPAPI_CALL_SERVICEREGISTRATIONOPTIONS_REMOVEALLACTIVESUBSERVICECODERANGES(
            d_handle_p);
}
 
inline void ServiceRegistrationOptions::setGroupId(
        const char *groupId, unsigned int groupIdLength)
{
    blpapi_ServiceRegistrationOptions_setGroupId(
            d_handle_p, groupId, groupIdLength);
}
 
inline int ServiceRegistrationOptions::setServicePriority(int priority)
{
    return blpapi_ServiceRegistrationOptions_setServicePriority(
            d_handle_p, priority);
}
 
inline void ServiceRegistrationOptions::setPartsToRegister(int parts)
{
    BLPAPI_CALL_SERVICEREGISTRATIONOPTIONS_SETPARTSTOREGISTER(
            d_handle_p, parts);
}
 
inline int ServiceRegistrationOptions::getGroupId(
        char *groupIdBuffer, int *groupIdLength) const
{
    return blpapi_ServiceRegistrationOptions_getGroupId(
            d_handle_p, groupIdBuffer, groupIdLength);
}
 
inline int ServiceRegistrationOptions::getServicePriority() const
{
    return blpapi_ServiceRegistrationOptions_getServicePriority(d_handle_p);
}
 
inline int ServiceRegistrationOptions::getPartsToRegister() const
{
    return BLPAPI_CALL_SERVICEREGISTRATIONOPTIONS_GETPARTSTOREGISTER(
            d_handle_p);
}

inline blpapi_ServiceRegistrationOptions_t *
ServiceRegistrationOptions::handle() const
{
    return d_handle_p;
}
 
// --------------------------
// class ProviderEventHandler
// --------------------------

extern "C" inline void blpapi_providerEventHandlerAdapter(
        blpapi_Event_t *event, blpapi_ProviderSession_t *, void *userData)
{
    assert(userData);
 
    reinterpret_cast<ProviderSession *>(userData)->dispatchEvent(Event(event));
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(
        ServiceRegistrationOptions::ServiceRegistrationPriority priority)
{
    switch (priority) {
    case ServiceRegistrationOptions::PRIORITY_LOW:
        return "PRIORITY_LOW";
    case ServiceRegistrationOptions::PRIORITY_MEDIUM:
        return "PRIORITY_MEDIUM";
    case ServiceRegistrationOptions::PRIORITY_HIGH:
        return "PRIORITY_HIGH";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(
        ServiceRegistrationOptions::RegistrationParts parts)
{
    switch (parts) {
    case ServiceRegistrationOptions::PART_PUBLISHING:
        return "PART_PUBLISHING";
    case ServiceRegistrationOptions::PART_OPERATIONS:
        return "PART_OPERATIONS";
    case ServiceRegistrationOptions::PART_SUBSCRIBER_RESOLUTION:
        return "PART_SUBSCRIBER_RESOLUTION";
    case ServiceRegistrationOptions::PART_PUBLISHER_RESOLUTION:
        return "PART_PUBLISHER_RESOLUTION";
    case ServiceRegistrationOptions::PART_DEFAULT:
        return "PART_DEFAULT";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(ProviderSession::ResolveMode resolveMode)
{
    switch (resolveMode) {
    case ProviderSession::AUTO_REGISTER_SERVICES:
        return "AUTO_REGISTER_SERVICES";
    case ProviderSession::DONT_REGISTER_SERVICES:
        return "DONT_REGISTER_SERVICES";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_PROVIDERSESSION