bmqt_correlationid.h

Go to the documentation of this file.

// Copyright 2014-2023 Bloomberg Finance L.P.
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
// bmqt_correlationid.h                                               -*-C++-*-
#ifndef INCLUDED_BMQT_CORRELATIONID
#define INCLUDED_BMQT_CORRELATIONID
 
 
// BDE
#include <bdlb_variant.h>
 
#include <bsl_cstdint.h>
#include <bsl_iosfwd.h>
#include <bsl_memory.h>
#include <bslh_hash.h>
#include <bsls_assert.h>
#include <bsls_types.h>
 
namespace BloombergLP {
namespace bmqt {
 
// ===================
// class CorrelationId
// ===================
 
class CorrelationId {
    // FRIENDS
    //  Needed to access getAsAutoValue
    friend bool operator==(const CorrelationId& lhs, const CorrelationId& rhs);
    friend bool operator!=(const CorrelationId& lhs, const CorrelationId& rhs);
    friend struct CorrelationIdLess;
    friend bsl::ostream& operator<<(bsl::ostream&        stream,
                                    const CorrelationId& rhs);
 
    template <class HASH_ALGORITHM>
    friend void hashAppend(HASH_ALGORITHM&      hashAlgo,
                           const CorrelationId& value);
 
  private:
    // PRIVATE TYPES
 
    typedef bsls::Types::Uint64 AutoValue;
 
    // DATA
 
    bdlb::Variant4<bsls::Types::Int64, void*, bsl::shared_ptr<void>, AutoValue>
        d_variant;
 
    // PRIVATE ACCESSORS
 
    AutoValue theAutoValue() const;
 
  public:
    // TYPES
    enum Type {
        e_NUMERIC  // the 'CorrelationId' holds a 64-bit integer
        ,
        e_POINTER  // the 'CorrelationId' holds a raw pointer
        ,
        e_SHARED_PTR  // the 'CorrelationId' holds a shared pointer
        ,
        e_AUTO_VALUE  // the 'CorrelationId' holds an auto value
        ,
        e_UNSET  // the 'CorrelationId' is not set
    };
 
    // CLASS METHOD
 
    static CorrelationId autoValue();
 
    // CREATORS
 
    explicit CorrelationId();
 
    explicit CorrelationId(bsls::Types::Int64 numeric);
 
    explicit CorrelationId(void* pointer);
 
    explicit CorrelationId(const bsl::shared_ptr<void>& sharedPtr);
 
    // MANIPULATORS
 
    CorrelationId& makeUnset();
 
    CorrelationId& setNumeric(bsls::Types::Int64 numeric);
 
    CorrelationId& setPointer(void* pointer);
 
    CorrelationId& setSharedPointer(const bsl::shared_ptr<void>& sharedPtr);
 
    // void setAutoValue
    // There is explicitly no setAuto, autoCorrelation should only be used
    // at creation
 
    // ACCESSORS
 
    bool isUnset() const;
 
    bool isNumeric() const;
 
    bool isPointer() const;
 
    bool isSharedPtr() const;
 
    bool isAutoValue() const;
 
    bsls::Types::Int64 theNumeric() const;
 
    void* thePointer() const;
 
    const bsl::shared_ptr<void>& theSharedPtr() const;
 
    Type type() const;
 
    bsl::ostream&
    print(bsl::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};
 
// FREE OPERATORS
 
// -------------------
// class CorrelationId
// -------------------
 
bsl::ostream& operator<<(bsl::ostream& stream, const CorrelationId& rhs);
 
bool operator==(const CorrelationId& lhs, const CorrelationId& rhs);
 
bool operator!=(const CorrelationId& lhs, const CorrelationId& rhs);
 
bool operator<(const CorrelationId& lhs, const CorrelationId& rhs);
 
// =======================
// class CorrelationIdLess
// =======================
 
struct CorrelationIdLess {
    // ACCESSORS
 
    bool operator()(const CorrelationId& lhs, const CorrelationId& rhs) const;
};
 
// ============================================================================
//                             INLINE DEFINITIONS
// ============================================================================
 
// -------------------
// class CorrelationId
// -------------------
 
inline CorrelationId::AutoValue CorrelationId::theAutoValue() const
{
    // PRECONDITIONS
    BSLS_ASSERT(isAutoValue());
 
    return d_variant.the<AutoValue>();
}
 
// CREATORS
inline CorrelationId::CorrelationId()
: d_variant()
{
    // NOTHING
}
 
inline CorrelationId::CorrelationId(bsls::Types::Int64 numeric)
: d_variant(numeric)
{
    // NOTHING
}
 
inline CorrelationId::CorrelationId(void* pointer)
: d_variant(pointer)
{
    // NOTHING
}
 
inline CorrelationId::CorrelationId(const bsl::shared_ptr<void>& sharedPtr)
: d_variant(sharedPtr)
{
    // NOTHING
}
 
// MANIPULATORS
inline CorrelationId& CorrelationId::makeUnset()
{
    d_variant.reset();
    return *this;
}
 
inline CorrelationId& CorrelationId::setNumeric(bsls::Types::Int64 numeric)
{
    d_variant.assign(numeric);
    return *this;
}
 
inline CorrelationId& CorrelationId::setPointer(void* pointer)
{
    d_variant.assign(pointer);
    return *this;
}
 
inline CorrelationId&
CorrelationId::setSharedPointer(const bsl::shared_ptr<void>& sharedPtr)
{
    d_variant.assign(sharedPtr);
    return *this;
}
 
// ACCESSORS
inline bool CorrelationId::isUnset() const
{
    return d_variant.isUnset();
}
 
inline bool CorrelationId::isNumeric() const
{
    return d_variant.is<bsls::Types::Int64>();
}
 
inline bool CorrelationId::isPointer() const
{
    return d_variant.is<void*>();
}
 
inline bool CorrelationId::isSharedPtr() const
{
    return d_variant.is<bsl::shared_ptr<void> >();
}
 
inline bool CorrelationId::isAutoValue() const
{
    return d_variant.is<AutoValue>();
}
 
inline bsls::Types::Int64 CorrelationId::theNumeric() const
{
    // PRECONDITIONS
    BSLS_ASSERT(isNumeric());
 
    return d_variant.the<bsls::Types::Int64>();
}
 
inline void* CorrelationId::thePointer() const
{
    // PRECONDITIONS
    BSLS_ASSERT(isPointer());
 
    return d_variant.the<void*>();
}
 
inline const bsl::shared_ptr<void>& CorrelationId::theSharedPtr() const
{
    // PRECONDITIONS
    BSLS_ASSERT(isSharedPtr());
 
    return d_variant.the<bsl::shared_ptr<void> >();
}
 
inline CorrelationId::Type CorrelationId::type() const
{
    int result = isUnset()       ? e_UNSET
                 : isNumeric()   ? e_NUMERIC
                 : isPointer()   ? e_POINTER
                 : isSharedPtr() ? e_SHARED_PTR
                 : isAutoValue() ? e_AUTO_VALUE
                                 : -1;
    BSLS_ASSERT_OPT(-1 != result && "Unknown correlation type");
 
    return static_cast<Type>(result);
}
 
// FREE FUNCTIONS
template <class HASH_ALGORITHM>
void hashAppend(HASH_ALGORITHM& hashAlgo, const CorrelationId& value)
{
    using bslh::hashAppend;  // for ADL
 
    CorrelationId::Type type = value.type();
    hashAppend(hashAlgo, static_cast<int>(type));
 
    switch (type) {
    case CorrelationId::e_NUMERIC: {
        hashAppend(hashAlgo, value.theNumeric());
    } break;
    case CorrelationId::e_POINTER: {
        hashAppend(hashAlgo, value.thePointer());
    } break;
    case CorrelationId::e_SHARED_PTR: {
        hashAppend(hashAlgo, value.theSharedPtr());
    } break;
    case CorrelationId::e_AUTO_VALUE: {
        hashAppend(hashAlgo, value.theAutoValue());
    } break;
    case CorrelationId::e_UNSET: {
        hashAppend(hashAlgo, 0);
    } break;
    default: {
        BSLS_ASSERT_OPT(false && "Unknown correlationId type");
        hashAppend(hashAlgo, 0);
    }
    }
}
 
// ------------------------
// struct CorrelationIdLess
// ------------------------
 
inline bool CorrelationIdLess::operator()(const CorrelationId& lhs,
                                          const CorrelationId& rhs) const
{
    // If 'lhs' and 'rhs' have different types, they are compared by their
    // corresponding type indices.  Otherwise, they are compared by value.
 
    bool result;
    if (lhs.d_variant.typeIndex() != rhs.d_variant.typeIndex()) {
        result = lhs.d_variant.typeIndex() < rhs.d_variant.typeIndex();
    }
    else if (lhs.isNumeric()) {
        result = lhs.theNumeric() < rhs.theNumeric();
    }
    else if (lhs.isPointer()) {
        result = reinterpret_cast<bsl::uintptr_t>(lhs.thePointer()) <
                 reinterpret_cast<bsl::uintptr_t>(rhs.thePointer());
    }
    else if (lhs.isSharedPtr()) {
        result = lhs.theSharedPtr() < rhs.theSharedPtr();
    }
    else if (lhs.isAutoValue()) {
        result = lhs.theAutoValue() < rhs.theAutoValue();
    }
    else {
        BSLS_ASSERT_OPT(false && "Unknown correlator type");
        result = false;
    }
 
    return result;
}
 
}  // close package namespace
 
// -------------------
// class CorrelationId
// -------------------
 
// FREE OPERATORS
inline bool bmqt::operator==(const bmqt::CorrelationId& lhs,
                             const bmqt::CorrelationId& rhs)
{
    return lhs.d_variant == rhs.d_variant;
}
 
inline bool bmqt::operator!=(const bmqt::CorrelationId& lhs,
                             const bmqt::CorrelationId& rhs)
{
    return lhs.d_variant != rhs.d_variant;
}
 
inline bool bmqt::operator<(const bmqt::CorrelationId& lhs,
                            const bmqt::CorrelationId& rhs)
{
    CorrelationIdLess less;
    return less(lhs, rhs);
}
 
inline bsl::ostream& bmqt::operator<<(bsl::ostream&              stream,
                                      const bmqt::CorrelationId& rhs)
{
    return rhs.print(stream, 0, -1);
}
 
}  // close enterprise namespace
 
#endif