bmqa_message.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.
 
// bmqa_message.h                                                     -*-C++-*-
#ifndef INCLUDED_BMQA_MESSAGE
#define INCLUDED_BMQA_MESSAGE
 
 
// BMQ
 
#include <bmqa_queueid.h>
#include <bmqt_compressionalgorithmtype.h>
#include <bmqt_correlationid.h>
#include <bmqt_messageguid.h>
#include <bmqt_subscription.h>
 
// BDE
#include <bdlbb_blob.h>
#include <bsl_cstddef.h>  // for 'size_t'
#include <bsl_iosfwd.h>
#include <bsl_memory.h>
#include <bsl_string.h>
#include <bsla_annotations.h>
#include <bslma_allocator.h>
 
namespace BloombergLP {
 
// FORWARD DECLARATION
namespace bmqimp {
class Event;
}
namespace bmqp {
class MessageProperties_Schema;
}
 
namespace bmqa {
 
// FORWARD DECLARATION
class MessageProperties;
 
// ==================
// struct MessageImpl
// ==================
 
struct MessageImpl {
    // PUBLIC DATA
 
    bmqimp::Event* d_event_p;
 
    bsl::shared_ptr<bmqimp::Event> d_clonedEvent_sp;
 
    bmqa::QueueId d_queueId;
 
    bmqt::CorrelationId d_correlationId;
 
    bmqt::SubscriptionHandle d_subscriptionHandle;
 
    bsl::shared_ptr<const bmqp::MessageProperties_Schema> d_schema_sp;
 
#ifdef BMQ_ENABLE_MSG_GROUPID
    bsl::string d_groupId;
#endif
};
 
// ===============================
// class MessageConfirmationCookie
// ===============================
 
class MessageConfirmationCookie {
  private:
    // DATA
 
    bmqa::QueueId d_queueId;
 
    bmqt::MessageGUID d_guid;
 
  public:
    // CREATORS
 
    MessageConfirmationCookie();
 
    MessageConfirmationCookie(const QueueId&           queueId,
                              const bmqt::MessageGUID& messageGUID);
 
    // ACCESSORS
 
    const QueueId& queueId() const;
 
    const bmqt::MessageGUID& messageGUID() const;
};
 
// =============
// class Message
// =============
 
class Message {
#ifdef BMQ_ENABLE_MSG_GROUPID
  public:
    // CONSTANTS
 
    static const int k_GROUP_ID_MAX_LENGTH = 31;
#endif
 
  private:
    // DATA
    mutable MessageImpl d_impl;  // pimpl
 
  private:
    // PRIVATE ACCESSORS
 
    bool isInitialized() const;
 
  public:
    // CREATORS
 
    Message();
 
    // MANIPULATORS
 
    BSLA_DEPRECATED_MESSAGE("Use `setDataRef() instead.")
    Message& setData(const bdlbb::Blob* data);
 
    BSLA_DEPRECATED_MESSAGE("Use `setDataRef() instead.")
    Message& setData(const char* data, size_t length);
 
    Message& setDataRef(const bdlbb::Blob* data);
 
    Message& setDataRef(const char* data, size_t length);
 
    Message& setPropertiesRef(const MessageProperties* properties);
 
    Message& clearPropertiesRef();
 
    Message& setCorrelationId(const bmqt::CorrelationId& correlationId);
 
    Message&
    setCompressionAlgorithmType(bmqt::CompressionAlgorithmType::Enum value);
 
#ifdef BMQ_ENABLE_MSG_GROUPID
    Message& setGroupId(const bsl::string& groupId);
 
    Message& clearGroupId();
#endif
 
    // ACCESSORS
 
    bool isValid() const;  // TBD:BSLA_DEPRECATED
 
    operator bool() const;  // TBD:BSLA_DEPRECATED
 
    Message clone(bslma::Allocator* basicAllocator = 0) const;
 
    const bmqa::QueueId& queueId() const;
 
    const bmqt::CorrelationId& correlationId() const;
 
    const bmqt::SubscriptionHandle& subscriptionHandle() const;
 
    bmqt::CompressionAlgorithmType::Enum compressionAlgorithmType() const;
 
#ifdef BMQ_ENABLE_MSG_GROUPID
    const bsl::string& groupId() const;
#endif
 
    const bmqt::MessageGUID& messageGUID() const;
 
    MessageConfirmationCookie confirmationCookie() const;
 
    int ackStatus() const;
 
    int getData(bdlbb::Blob* blob) const;
 
    int dataSize() const;
 
    bool hasProperties() const;
 
#ifdef BMQ_ENABLE_MSG_GROUPID
    bool hasGroupId() const;
#endif
 
    int loadProperties(MessageProperties* buffer) const;
 
    bsl::ostream&
    print(bsl::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};
 
// FREE OPERATORS
 
bsl::ostream& operator<<(bsl::ostream& stream, const Message& rhs);
 
// ============================================================================
//                             INLINE DEFINITIONS
// ============================================================================
 
// -------------
// class Message
// -------------
 
inline Message& Message::setData(const bdlbb::Blob* data)
{
    return setDataRef(data);
}
 
inline Message& Message::setData(const char* data, size_t length)
{
    return setDataRef(data, length);
}
 
inline Message::operator bool() const
{
    return isInitialized();
}
 
// -------------------------------
// class MessageConfirmationCookie
// -------------------------------
 
inline MessageConfirmationCookie::MessageConfirmationCookie()
: d_queueId()
, d_guid()
{
    // NOTHING
}
 
inline MessageConfirmationCookie::MessageConfirmationCookie(
    const bmqa::QueueId&     queueId,
    const bmqt::MessageGUID& messageGUID)
: d_queueId(queueId)
, d_guid(messageGUID)
{
    // NOTHING
}
 
// ACCESSORS
inline const QueueId& MessageConfirmationCookie::queueId() const
{
    return d_queueId;
}
 
inline const bmqt::MessageGUID& MessageConfirmationCookie::messageGUID() const
{
    return d_guid;
}
}  // close package namespace
 
// -------------
// class Message
// -------------
 
// FREE OPERATORS
inline bsl::ostream& bmqa::operator<<(bsl::ostream&        stream,
                                      const bmqa::Message& rhs)
{
    return rhs.print(stream, 0, -1);
}
 
}  // close enterprise namespace
 
#endif