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

 
#include <blpapi_call.h>
#include <blpapi_defs.h>
#include <blpapi_exception.h>
#include <blpapi_types.h>
 
#include <stddef.h>
 
#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; 
    unsigned int valueType
            : 4; 
    unsigned int classId
            : 16; 
    unsigned int internalClassId : 4; 
 
    union {
        blpapi_UInt64_t intValue; 
        blpapi_ManagedPtr_t
                ptrValue; 
    } value; 
} blpapi_CorrelationId_t;

BLPAPI_EXPORT
int blpapi_CorrelationId_managedPtrAddRef(
        int *numRef, blpapi_CorrelationId_t *cid);

BLPAPI_EXPORT
int blpapi_CorrelationId_managedPtrRelease(
        int *numRef, blpapi_CorrelationId_t *cid);

BLPAPI_EXPORT
int blpapi_CorrelationId_hash(size_t *hash, const blpapi_CorrelationId_t *cid);

 
#ifdef __cplusplus
}
 
#include <cstring>
#include <ostream>
#include <utility>
 
namespace BloombergLP {
namespace blpapi {
 
// ===================
// class CorrelationId
// ===================

class CorrelationId {
 
    enum {
        e_FOREIGN_OBJECT = BLPAPI_CORRELATION_INTERNAL_CLASS_FOREIGN_OBJECT
    };

    blpapi_CorrelationId_t d_impl;
 
    void copy(const blpapi_CorrelationId_t& src, bool firstCopy);
 
    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);
 
namespace util {

 
constexpr const char *to_string(CorrelationId::ValueType valueType);

 
} // close namespace util
 
//=============================================================================
//                           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, /* firstCopy = */ true);
}
 
inline CorrelationId::CorrelationId(const CorrelationId& original)
{
    copy(original.d_impl, /* firstCopy = */ false);
}
 
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) {
            int numRef = 0;
            if (d_impl.internalClassId == e_FOREIGN_OBJECT
                    && BLPAPI_CALL_AVAILABLE(
                            blpapi_CorrelationId_managedPtrRelease)
                    && BLPAPI_CALL_UNCHECKED(
                               blpapi_CorrelationId_managedPtrRelease)(
                               &numRef, &d_impl)
                            == 0
                    && numRef > 0) {
                return;
            }
            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, bool firstCopy)
{
    d_impl = src;
 
    if (POINTER_VALUE == valueType()) {
        blpapi_ManagedPtr_ManagerFunction_t& manager
                = d_impl.value.ptrValue.manager;
        if (manager) {
            if (d_impl.internalClassId == e_FOREIGN_OBJECT) {
                if (firstCopy) {
                    // This CorrelationId is created from a C-handle, not from
                    // another C++ CorrelationId. But this C-handle can contain
                    // a pointer to a reference counter previously created in
                    // C++ layer. It is unsafe to reuse as it might be a
                    // dangling pointer by this time. Reset userData. This
                    // allows to create a new reference counter for new C++
                    // copies of this CorrelationId.
                    std::memset(&d_impl.value.ptrValue.userData,
                            0,
                            sizeof(d_impl.value.ptrValue.userData));
                }
                int numRef = 0;
                ExceptionUtil::throwOnError(
                        BLPAPI_CALL(blpapi_CorrelationId_managedPtrAddRef)(
                                &numRef, &d_impl));
                if (numRef > 1) {
                    return;
                }
            }
            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.impl().internalClassId != rhs.impl().internalClassId) {
        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)
{
    if (lhs.valueType() == CorrelationId::POINTER_VALUE
            && lhs.impl().internalClassId
                    == BLPAPI_CORRELATION_INTERNAL_CLASS_FOREIGN_OBJECT
            && rhs.valueType() == CorrelationId::POINTER_VALUE
            && rhs.impl().internalClassId
                    == BLPAPI_CORRELATION_INTERNAL_CLASS_FOREIGN_OBJECT) {
        return lhs.classId() == rhs.classId()
                ? lhs.asPointer() < rhs.asPointer()
                : lhs.classId() < rhs.classId();
    }
    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()
       << " internalClassId=" << correlator.impl().internalClassId
       << " value=";
 
    if (correlator.valueType() == CorrelationId::POINTER_VALUE) {
        os << correlator.asPointer();
    } else {
        os << correlator.asInteger();
    }
    os << " ]";
 
    return os;
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(CorrelationId::ValueType valueType)
{
    switch (valueType) {
    case CorrelationId::UNSET_VALUE:
        return "UNSET_VALUE";
    case CorrelationId::INT_VALUE:
        return "INT_VALUE";
    case CorrelationId::POINTER_VALUE:
        return "POINTER_VALUE";
    case CorrelationId::AUTOGEN_VALUE:
        return "AUTOGEN_VALUE";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_CORRELATIONID