blpapi_correlationid.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_CORRELATIONID
#define INCLUDED_BLPAPI_CORRELATIONID

#ifndef INCLUDED_BLPAPI_TYPES
#include <blpapi_types.h>
#endif

#ifndef INCLUDED_BLPAPI_DEFS
#include <blpapi_defs.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

struct blpapi_ManagedPtr_t_;
typedef struct blpapi_ManagedPtr_t_ blpapi_ManagedPtr_t;

typedef int (*blpapi_ManagedPtr_ManagerFunction_t)(
        blpapi_ManagedPtr_t *managedPtr,
        const blpapi_ManagedPtr_t *srcPtr,
        int operation);

typedef union {
    int intValue;
    void *ptr;
} blpapi_ManagedPtr_t_data_;

struct blpapi_ManagedPtr_t_ {
    void *pointer;
    blpapi_ManagedPtr_t_data_ userData[4];
    blpapi_ManagedPtr_ManagerFunction_t manager;
};

typedef struct blpapi_CorrelationId_t_ {
    unsigned int size : 8; // fill in the size of this struct
    unsigned int valueType : 4; // type of value held by this correlation id
    unsigned int classId : 16; // user defined classification id
    unsigned int reserved : 4; // for internal use must be 0

    union {
        blpapi_UInt64_t intValue;
        blpapi_ManagedPtr_t ptrValue;
    } value;
} blpapi_CorrelationId_t;

#ifdef __cplusplus
}


#include <cstring>
#include <ostream>
#include <utility>

namespace BloombergLP {
namespace blpapi {

// ===================
// class CorrelationId
// ===================

class CorrelationId {

    blpapi_CorrelationId_t d_impl;

    void copy(const blpapi_CorrelationId_t& src);

    template <typename TYPE>
    static int managerFunc(blpapi_ManagedPtr_t *managedPtr,
            const blpapi_ManagedPtr_t *srcPtr,
            int operation);

    template <typename TYPE> static void assertSmartPtrFits();

  public:
    // Possible return values for valueType() method.

    enum ValueType {
        UNSET_VALUE = BLPAPI_CORRELATION_TYPE_UNSET,
        INT_VALUE = BLPAPI_CORRELATION_TYPE_INT,
        POINTER_VALUE = BLPAPI_CORRELATION_TYPE_POINTER,
        AUTOGEN_VALUE = BLPAPI_CORRELATION_TYPE_AUTOGEN
    };

    // The maximum value allowed for classId

    enum {
        MAX_CLASS_ID = BLPAPI_CORRELATION_MAX_CLASS_ID 
    };

    CorrelationId();
    explicit CorrelationId(const blpapi_CorrelationId_t& correlation);

    CorrelationId(const CorrelationId& original);
    explicit CorrelationId(long long value, int classId = 0);
    explicit CorrelationId(void *value, int classId = 0);
    template <typename TYPE>
    CorrelationId(const TYPE& smartPtr, void *pointerValue, int classId = 0);
    ~CorrelationId();
    void swap(CorrelationId& other);
    CorrelationId& operator=(const CorrelationId& rhs);
    ValueType valueType() const;
    unsigned short classId() const;
    void *asPointer() const;
    template <typename TYPE> TYPE asSmartPointer() const;
    long long asInteger() const;
    blpapi_CorrelationId_t& impl();
    const blpapi_CorrelationId_t& impl() const;
};

// FREE OPERATORS
inline bool operator==(const CorrelationId& lhs, const CorrelationId& rhs);
inline bool operator!=(const CorrelationId& lhs, const CorrelationId& rhs);
inline bool operator<(const CorrelationId& lhs, const CorrelationId& rhs);
//=============================================================================
//                           INLINE FUNCTION DEFINITIONS
//=============================================================================

// -------------------
// class CorrelationId
// -------------------

inline CorrelationId::CorrelationId()
{
    std::memset(&d_impl, 0, sizeof(d_impl));
}

inline CorrelationId::CorrelationId(
        const blpapi_CorrelationId_t& correlationId)
{
    copy(correlationId);
}

inline CorrelationId::CorrelationId(const CorrelationId& original)
{
    copy(original.d_impl);
}

inline CorrelationId::CorrelationId(long long intValue, int newClassId)
{
    std::memset(&d_impl, 0, sizeof(d_impl));

    d_impl.size = static_cast<unsigned>(sizeof(d_impl));
    d_impl.valueType = INT_VALUE;
    d_impl.value.intValue = static_cast<blpapi_UInt64_t>(intValue);
    d_impl.classId = static_cast<unsigned>(newClassId);
}

inline CorrelationId::CorrelationId(void *ptrValue, int newClassId)
{
    std::memset(&d_impl, 0, sizeof(d_impl));

    d_impl.size = static_cast<unsigned>(sizeof(d_impl));
    d_impl.valueType = POINTER_VALUE;
    d_impl.value.ptrValue.pointer = ptrValue;
    d_impl.classId = static_cast<unsigned>(newClassId);
}

template <typename TYPE>
inline CorrelationId::CorrelationId(
        const TYPE& smartPtr, void *ptrValue, int newClassId)
{
    // If you get a compiler error here, the specified smart pointer does not
    // fit in the CorrelationId and cannot be used at this time.

    assertSmartPtrFits<TYPE>();

    std::memset(&d_impl, 0, sizeof(d_impl));

    d_impl.size = sizeof(d_impl);
    d_impl.valueType = POINTER_VALUE;
    d_impl.classId = newClassId;

    d_impl.value.ptrValue.pointer = ptrValue;
    d_impl.value.ptrValue.manager = &CorrelationId::managerFunc<TYPE>;

    void *arena = (void *)d_impl.value.ptrValue.userData;
    new (arena) TYPE(smartPtr);
}

inline CorrelationId::~CorrelationId()
{
    if (POINTER_VALUE == valueType()) {
        blpapi_ManagedPtr_ManagerFunction_t& manager
                = d_impl.value.ptrValue.manager;
        if (manager) {
            manager(&d_impl.value.ptrValue, 0, BLPAPI_MANAGEDPTR_DESTROY);
        }
    }
}

inline void CorrelationId::swap(CorrelationId& other)
{
    using std::swap;

    swap(other.d_impl, d_impl);
}

inline CorrelationId& CorrelationId::operator=(const CorrelationId& rhs)
{
    CorrelationId tmp(rhs);
    tmp.swap(*this);
    return *this;
}

inline blpapi_CorrelationId_t& CorrelationId::impl() { return d_impl; }

inline CorrelationId::ValueType CorrelationId::valueType() const
{
    return (ValueType)d_impl.valueType;
}

inline unsigned short CorrelationId::classId() const { return d_impl.classId; }

inline void *CorrelationId::asPointer() const
{
    return d_impl.value.ptrValue.pointer;
}

template <typename TYPE> inline TYPE CorrelationId::asSmartPointer() const
{
    typedef int (*ManagerFuncPtr)(
            blpapi_ManagedPtr_t *, const blpapi_ManagedPtr_t *, int);

    ManagerFuncPtr managerFnPtr
            = static_cast<ManagerFuncPtr>(&(CorrelationId::managerFunc<TYPE>));
    if (d_impl.valueType != POINTER_VALUE
            || (d_impl.value.ptrValue.manager != managerFnPtr)) {
        return TYPE();
    }
    return *(TYPE *)d_impl.value.ptrValue.userData;
}

inline long long CorrelationId::asInteger() const
{
    return static_cast<long long>(d_impl.value.intValue);
}

inline const blpapi_CorrelationId_t& CorrelationId::impl() const
{
    return d_impl;
}

inline void CorrelationId::copy(const blpapi_CorrelationId_t& src)
{
    d_impl = src;

    if (POINTER_VALUE == valueType()) {
        blpapi_ManagedPtr_ManagerFunction_t& manager
                = d_impl.value.ptrValue.manager;
        if (manager) {
            manager(&d_impl.value.ptrValue,
                    &src.value.ptrValue,
                    BLPAPI_MANAGEDPTR_COPY);
        }
    }
}

template <typename TYPE>
inline int CorrelationId::managerFunc(blpapi_ManagedPtr_t *managedPtr,
        const blpapi_ManagedPtr_t *srcPtr,
        int operation)
{
    if (operation == BLPAPI_MANAGEDPTR_COPY) {
        managedPtr->pointer = srcPtr->pointer;
        managedPtr->manager = srcPtr->manager;

        void *arena = managedPtr->userData;
        new (arena) TYPE(*((TYPE *)&srcPtr->userData[0]));
    } else if (operation == BLPAPI_MANAGEDPTR_DESTROY) {
        TYPE *managedPtr_p = (TYPE *)&managedPtr->userData[0];
        managedPtr_p->~TYPE();
    } else if (operation == BLPAPI_MANAGEDPTR_IMPOSSIBLE_OPERATION) {
        static int uniquePerTemplateInstantiation;

        const int *address = &uniquePerTemplateInstantiation;
        int rc = 0;
        std::memcpy(&rc, &address, std::min(sizeof address, sizeof rc));
        return rc;
        // Instantiations of this function template, 'managerFunc<TYPE>',
        // will never be called with 'operation' equal to
        // 'BLPAPI_MANAGEDPTR_IMPOSSIBLE_OPERATION': this branch will never
        // be executed.
        //
        // The observable use of the address of a local static variable
        // forces '&managerFunc<T1> != &managerFunc<T2>' for types
        // 'T1 != T2' even in the presence of Visual C++'s "identical
        // COMDAT folding" optimization.
    }

    return 0;
}

template <typename TYPE> inline void CorrelationId::assertSmartPtrFits()
{
    if (false) {
        // If you get a compiler error here, the specified smart pointer does
        // not fit in the CorrelationId and cannot be used at this time.

        char errorIfSmartPtrDoesNotFit[sizeof(TYPE) <= (sizeof(void *) * 4)
                        ? 1
                        : -1];
        (void)errorIfSmartPtrDoesNotFit;
    }
}

inline bool operator==(const CorrelationId& lhs, const CorrelationId& rhs)
{
    if (lhs.valueType() != rhs.valueType()) {
        return false;
    }
    if (lhs.classId() != rhs.classId()) {
        return false;
    }

    if (lhs.valueType() == CorrelationId::POINTER_VALUE) {
        if (lhs.asPointer() != rhs.asPointer()) {
            return false;
        }
    } else if (lhs.asInteger() != rhs.asInteger()) {
        return false;
    }

    return true;
}

inline bool operator!=(const CorrelationId& lhs, const CorrelationId& rhs)
{
    return !(lhs == rhs);
}

inline bool operator<(const CorrelationId& lhs, const CorrelationId& rhs)
{
    return std::memcmp(&lhs.impl(), &rhs.impl(), sizeof(rhs.impl())) < 0;
}

inline std::ostream& operator<<(
        std::ostream& os, const CorrelationId& correlator)
{
    const char *valueType = 0;
    switch (correlator.valueType()) {
    case CorrelationId::UNSET_VALUE:
        valueType = "UNSET";
        break;
    case CorrelationId::INT_VALUE:
        valueType = "INT";
        break;
    case CorrelationId::POINTER_VALUE:
        valueType = "POINTER";
        break;
    case CorrelationId::AUTOGEN_VALUE:
        valueType = "AUTOGEN";
        break;
    default:
        valueType = "UNKNOWN";
    }

    os << "[ valueType=" << valueType << " classId=" << correlator.classId()
       << " value=";

    if (correlator.valueType() == CorrelationId::POINTER_VALUE) {
        os << correlator.asPointer();
    } else
        os << correlator.asInteger();
    os << " ]";

    return os;
}

} // close namespace blpapi
} // close namespace BloombergLP

#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_CORRELATIONID