blpapi_subscriptionlist.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_SUBSCRIPTIONLIST
#define INCLUDED_BLPAPI_SUBSCRIPTIONLIST

#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_TYPES
#include <blpapi_types.h>
#endif

#include <stddef.h>

struct blpapi_SubscriptionList;
typedef struct blpapi_SubscriptionList blpapi_SubscriptionList_t;

#ifdef __cplusplus
extern "C" {
#endif

BLPAPI_EXPORT
blpapi_SubscriptionList_t *blpapi_SubscriptionList_create(void);

BLPAPI_EXPORT
void blpapi_SubscriptionList_destroy(blpapi_SubscriptionList_t *list);

BLPAPI_EXPORT
int blpapi_SubscriptionList_add(blpapi_SubscriptionList_t *list,
        const char *subscriptionString,
        const blpapi_CorrelationId_t *correlationId,
        const char **fields,
        const char **options,
        size_t numfields,
        size_t numOptions);

BLPAPI_EXPORT
int blpapi_SubscriptionList_addResolved(blpapi_SubscriptionList_t *list,
        const char *subscriptionString,
        const blpapi_CorrelationId_t *correlationId);

BLPAPI_EXPORT
int blpapi_SubscriptionList_clear(blpapi_SubscriptionList_t *list);

BLPAPI_EXPORT
int blpapi_SubscriptionList_append(
        blpapi_SubscriptionList_t *dest, const blpapi_SubscriptionList_t *src);

BLPAPI_EXPORT
int blpapi_SubscriptionList_size(const blpapi_SubscriptionList_t *list);

BLPAPI_EXPORT
int blpapi_SubscriptionList_correlationIdAt(
        const blpapi_SubscriptionList_t *list,
        blpapi_CorrelationId_t *result,
        size_t index);

BLPAPI_EXPORT
int blpapi_SubscriptionList_topicStringAt(
        blpapi_SubscriptionList_t *list, const char **result, size_t index);

BLPAPI_EXPORT
int blpapi_SubscriptionList_isResolvedAt(
        blpapi_SubscriptionList_t *list, int *result, size_t index);

#ifdef __cplusplus
}

#ifndef INCLUDED_CSTRING
#include <cstring>
#define INCLUDED_CSTRING
#endif

#ifndef INCLUDED_STRING
#include <string>
#define INCLUDED_STRING
#endif

#ifndef INCLUDED_VECTOR
#include <vector>
#define INCLUDED_VECTOR
#endif

namespace BloombergLP {
namespace blpapi {

// ======================
// class SubscriptionList
// ======================

class SubscriptionList {

    blpapi_SubscriptionList_t *d_handle_p;

  public:
    SubscriptionList();
    SubscriptionList(const SubscriptionList& original);
    ~SubscriptionList();
    // MANIPULATORS

    int add(const char *subscriptionString);
    int add(const char *subscriptionString,
            const CorrelationId& correlationId);
    int add(const char *subscriptionWithoutOptions,
            const std::vector<std::string>& fields,
            const std::vector<std::string>& options,
            const CorrelationId& correlationId);
    int add(const char *subscriptionWithoutOptions,
            const char *fields,
            const char *options,
            const CorrelationId& correlationId);
    int add(const CorrelationId& correlationId);
    int addResolved(const char *subscriptionString);
    int addResolved(const char *subscriptionString,
            const CorrelationId& correlationId);
    int append(const SubscriptionList& other);
    void clear();
    SubscriptionList& operator=(const SubscriptionList& rhs);
    // ACCESSORS

    size_t size() const;
    CorrelationId correlationIdAt(size_t index) const;
    const char *topicStringAt(size_t index) const;
    bool isResolvedTopicAt(size_t index) const;
    const blpapi_SubscriptionList_t *impl() const;
};

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

// ----------------------
// class SubscriptionList
// ----------------------
inline SubscriptionList::SubscriptionList()
    : d_handle_p(blpapi_SubscriptionList_create())
{
}

inline SubscriptionList::SubscriptionList(const SubscriptionList& original)
    : d_handle_p(blpapi_SubscriptionList_create())
{
    blpapi_SubscriptionList_append(d_handle_p, original.d_handle_p);
}

inline SubscriptionList::~SubscriptionList()
{
    blpapi_SubscriptionList_destroy(d_handle_p);
}

inline int SubscriptionList::add(const char *subscriptionString)
{
    blpapi_CorrelationId_t correlationId;
    std::memset(&correlationId, 0, sizeof(correlationId));
    return blpapi_SubscriptionList_add(
            d_handle_p, subscriptionString, &correlationId, 0, 0, 0, 0);
}

inline int SubscriptionList::add(
        const char *subscriptionString, const CorrelationId& correlationId)
{
    return blpapi_SubscriptionList_add(
            d_handle_p, subscriptionString, &correlationId.impl(), 0, 0, 0, 0);
}

inline int SubscriptionList::add(const char *subscriptionString,
        const std::vector<std::string>& fields,
        const std::vector<std::string>& options,
        const CorrelationId& correlationId)
{
    std::vector<const char *> tmpVector;
    const char *arena[256];
    const char **tmpArray = arena;
    size_t sizeNeeded = fields.size() + options.size();

    if (sizeNeeded > sizeof(arena) / sizeof(arena[0])) {
        tmpVector.resize(sizeNeeded);
        tmpArray = &tmpVector[0];
    }

    const char **p = tmpArray;
    for (std::vector<std::string>::const_iterator itr = fields.begin(),
                                                  end = fields.end();
            itr != end;
            ++itr, ++p) {
        *p = itr->c_str();
    }

    for (std::vector<std::string>::const_iterator itr = options.begin(),
                                                  end = options.end();
            itr != end;
            ++itr, ++p) {
        *p = itr->c_str();
    }

    return blpapi_SubscriptionList_add(d_handle_p,
            subscriptionString,
            &correlationId.impl(),
            tmpArray,
            tmpArray + fields.size(),
            fields.size(),
            options.size());
}

inline int SubscriptionList::add(const char *subscriptionString,
        const char *fields,
        const char *options,
        const CorrelationId& correlationId)
{
    return blpapi_SubscriptionList_add(d_handle_p,
            subscriptionString,
            &correlationId.impl(),
            &fields,
            &options,
            fields ? 1u : 0u,
            options ? 1u : 0u);
}

inline int SubscriptionList::add(const CorrelationId& correlationId)
{
    return blpapi_SubscriptionList_add(
            d_handle_p, "", &correlationId.impl(), 0, 0, 0, 0);
}

inline int SubscriptionList::addResolved(const char *subscriptionString)
{
    blpapi_CorrelationId_t correlationId;
    std::memset(&correlationId, 0, sizeof(correlationId));
    return BLPAPI_CALL_SUBSCRIPTIONLIST_ADDRESOLVED(
            d_handle_p, subscriptionString, &correlationId);
}

inline int SubscriptionList::addResolved(
        const char *subscriptionString, const CorrelationId& correlationId)
{
    return BLPAPI_CALL_SUBSCRIPTIONLIST_ADDRESOLVED(
            d_handle_p, subscriptionString, &correlationId.impl());
}

inline int SubscriptionList::append(const SubscriptionList& other)
{
    return blpapi_SubscriptionList_append(d_handle_p, other.d_handle_p);
}

inline void SubscriptionList::clear()
{
    blpapi_SubscriptionList_clear(d_handle_p);
}

inline SubscriptionList& SubscriptionList::operator=(
        const SubscriptionList& rhs)
{
    if (d_handle_p != rhs.d_handle_p) {
        blpapi_SubscriptionList_clear(d_handle_p);
        blpapi_SubscriptionList_append(d_handle_p, rhs.d_handle_p);
    }
    return *this;
}

inline size_t SubscriptionList::size() const
{
    return static_cast<size_t>(blpapi_SubscriptionList_size(d_handle_p));
}

inline CorrelationId SubscriptionList::correlationIdAt(size_t index) const
{
    blpapi_CorrelationId_t correlationId;

    ExceptionUtil::throwOnError(blpapi_SubscriptionList_correlationIdAt(
            d_handle_p, &correlationId, index));

    return CorrelationId(correlationId);
}

inline const char *SubscriptionList::topicStringAt(size_t index) const
{
    const char *result = 0;

    ExceptionUtil::throwOnError(
            blpapi_SubscriptionList_topicStringAt(d_handle_p, &result, index));

    return result;
}

inline bool SubscriptionList::isResolvedTopicAt(size_t index) const
{
    int result = 0;

    ExceptionUtil::throwOnError(BLPAPI_CALL_SUBSCRIPTIONLIST_ISRESOLVEDAT(
            d_handle_p, &result, index));

    return result ? true : false;
}

inline const blpapi_SubscriptionList_t *SubscriptionList::impl() const
{
    return d_handle_p;
}

} // close package namespace
} // close enterprise namespace

#endif // ifdef __cplusplus

#endif // #ifndef INCLUDED_BLPAPI_SUBSCRIPTIONLIST