bmqt_messageguid.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_messageguid.h                                                 -*-C++-*-
#ifndef INCLUDED_BMQT_MESSAGEGUID
#define INCLUDED_BMQT_MESSAGEGUID
 
 
// BDE
#include <bsl_cstring.h>  // for bsl::memset, bsl::memcmp
 
#include <bsl_iosfwd.h>
#include <bsl_type_traits.h>
#include <bsla_annotations.h>
#include <bslh_hash.h>
#include <bslmf_isbitwiseequalitycomparable.h>
#include <bslmf_istriviallycopyable.h>
#include <bslmf_nestedtraitdeclaration.h>
#include <bsls_types.h>
 
namespace BloombergLP {
namespace bmqt {
 
// =================
// class MessageGUID
// =================
 
class MessageGUID {
    // FRIENDS
    friend bool operator==(const MessageGUID& lhs, const MessageGUID& rhs);
    friend bool operator!=(const MessageGUID& lhs, const MessageGUID& rhs);
    friend struct MessageGUIDLess;
    template <class HASH_ALGORITHM>
    friend void hashAppend(HASH_ALGORITHM& hashAlgo, const MessageGUID& guid);
 
  public:
    // TYPES
 
    enum Enum {
        e_SIZE_BINARY = 16
 
        ,
        e_SIZE_HEX = 2 * e_SIZE_BINARY
    };
 
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(MessageGUID,
                                   bslmf::IsBitwiseEqualityComparable)
    BSLMF_NESTED_TRAIT_DECLARATION(MessageGUID, bsl::is_trivially_copyable)
 
  private:
    // PRIVATE CONSTANTS
 
    static const char k_UNSET_GUID[e_SIZE_BINARY];
 
  private:
    // IMPLEMENTATION NOTE: Some structs in bmqp::Protocol.h blindly
    //                      reinterpret_cast a char[e_SIZE_BINARY] to a
    //                      MessageGUID (instead of using 'fromBinary()') so
    //                      that they can return a const MessageGUID&.
    // IMPLEMENTATION NOTE: See mqbu_messageguidutil.cpp for internal layout of
    //                      MessageGUID
 
    // DATA
    char d_buffer[e_SIZE_BINARY];
 
  public:
    // CLASS METHODS
 
    static bool isValidHexRepresentation(const char* buffer);
 
    // CREATORS
 
    MessageGUID();
 
    ~MessageGUID();
 
    // MANIPULATORS
 
    MessageGUID& fromBinary(const unsigned char* buffer);
 
    MessageGUID& fromHex(const char* buffer);
 
    // ACCESSORS
 
    bool isUnset() const;
 
    void toBinary(unsigned char* destination) const;
 
    void toHex(char* destination) const;
 
    bsl::ostream&
    print(bsl::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};
 
// FREE OPERATORS
 
// -----------------
// class MessageGUID
// -----------------
 
bsl::ostream& operator<<(bsl::ostream& stream, const MessageGUID& rhs);
 
bool operator==(const MessageGUID& lhs, const MessageGUID& rhs);
 
bool operator!=(const MessageGUID& lhs, const MessageGUID& rhs);
 
bool operator<(const MessageGUID& lhs, const MessageGUID& rhs);
 
// =====================
// class MessageGUIDLess
// =====================
 
struct MessageGUIDLess {
    // ACCESSORS
 
    bool operator()(const MessageGUID& lhs, const MessageGUID& rhs) const;
};
 
// =========================
// class MessageGUIDHashAlgo
// =========================
 
class MessageGUIDHashAlgo {
  private:
    // DATA
    bsls::Types::Uint64 d_result;
 
  public:
    // TYPES
    typedef bsls::Types::Uint64 result_type;
 
    // CREATORS
 
    MessageGUIDHashAlgo();
 
    // MANIPULATORS
    void operator()(const void* data, size_t numBytes);
 
    result_type computeHash();
};
 
// ============================================================================
//                             INLINE DEFINITIONS
// ============================================================================
 
// -----------------
// class MessageGUID
// -----------------
 
// CREATORS
inline MessageGUID::MessageGUID()
{
    bsl::memcpy(d_buffer, k_UNSET_GUID, e_SIZE_BINARY);
}
 
inline MessageGUID::~MessageGUID()
{
#ifdef BSLS_ASSERT_SAFE_IS_ACTIVE
    bsl::memcpy(d_buffer, k_UNSET_GUID, e_SIZE_BINARY);
#endif
}
 
// ACCESSORS
inline bool MessageGUID::isUnset() const
{
    return 0 == bsl::memcmp(d_buffer, k_UNSET_GUID, e_SIZE_BINARY);
}
 
// FREE FUNCTIONS
template <class HASH_ALGORITHM>
void hashAppend(HASH_ALGORITHM& hashAlgo, const MessageGUID& guid)
{
    using bslh::hashAppend;               // for ADL
    hashAppend(hashAlgo, guid.d_buffer);  // hashes entire buffer array
}
 
// ----------------------
// struct MessageGUIDLess
// ----------------------
 
inline bool MessageGUIDLess::operator()(const MessageGUID& lhs,
                                        const MessageGUID& rhs) const
{
    return 0 >
           bsl::memcmp(lhs.d_buffer, rhs.d_buffer, MessageGUID::e_SIZE_BINARY);
}
 
// -------------------------
// class MessageGUIDHashAlgo
// -------------------------
 
// CREATORS
inline MessageGUIDHashAlgo::MessageGUIDHashAlgo()
: d_result(0)
{
}
 
// MANIPULATORS
inline void MessageGUIDHashAlgo::operator()(const void*        data,
                                            BSLA_UNUSED size_t numBytes)
{
    // Implementation note: the implementation is based on Jon Maiga's research
    // on different bit mixers and their qualities (look for `mxm`):
    // https://jonkagstrom.com/bit-mixer-construction/index.html
 
    // Typically, bit mixers are used as the last step of computing more
    // general hashes.  But it's more than enough to use it on its own for
    // our specific use case here.
 
    // Performance evaluation, hash quality and avalanche effect are here:
    // https://github.com/bloomberg/blazingmq/pull/348
 
    struct LocalFuncs {
        inline static bsls::Types::Uint64 mix(bsls::Types::Uint64 x)
        {
            x *= 0xbf58476d1ce4e5b9ULL;
            x ^= x >> 56;
            x *= 0x94d049bb133111ebULL;
            return x;
        }
 
        inline static bsls::Types::Uint64 combine(bsls::Types::Uint64 lhs,
                                                  bsls::Types::Uint64 rhs)
        {
            lhs ^= rhs + 0x517cc1b727220a95 + (lhs << 6) + (lhs >> 2);
            return lhs;
        }
    };
 
    // `data` buffer might not be aligned to 8 bytes, so recasting the pointer
    // might lead to UB
    bsls::Types::Uint64 parts[2];
    bsl::memcpy(parts, data, bmqt::MessageGUID::e_SIZE_BINARY);
 
    parts[0] = LocalFuncs::mix(parts[0]);
    parts[1] = LocalFuncs::mix(parts[1]);
    d_result = LocalFuncs::combine(parts[0], parts[1]);
}
 
inline MessageGUIDHashAlgo::result_type MessageGUIDHashAlgo::computeHash()
{
    return d_result;
}
 
}  // close package namespace
 
// -----------------
// class MessageGUID
// -----------------
 
// FREE OPERATORS
inline bool bmqt::operator==(const bmqt::MessageGUID& lhs,
                             const bmqt::MessageGUID& rhs)
{
    return 0 ==
           bsl::memcmp(lhs.d_buffer, rhs.d_buffer, MessageGUID::e_SIZE_BINARY);
}
 
inline bool bmqt::operator!=(const bmqt::MessageGUID& lhs,
                             const bmqt::MessageGUID& rhs)
{
    return !(lhs == rhs);
}
 
inline bool bmqt::operator<(const bmqt::MessageGUID& lhs,
                            const bmqt::MessageGUID& rhs)
{
    MessageGUIDLess less;
    return less(lhs, rhs);
}
 
inline bsl::ostream& bmqt::operator<<(bsl::ostream&            stream,
                                      const bmqt::MessageGUID& rhs)
{
    return rhs.print(stream, 0, -1);
}
 
}  // close enterprise namespace
 
#endif