bmqa_messageproperties.h

Go to the documentation of this file.

// Copyright 2016-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_messageproperties.h                                           -*-C++-*-
#ifndef INCLUDED_BMQA_MESSAGEPROPERTIES
#define INCLUDED_BMQA_MESSAGEPROPERTIES
 
 
// BMQ
 
#include <bmqt_propertytype.h>
#include <bmqt_resultcode.h>
 
// BDE
#include <bdlbb_blob.h>
#include <bsl_cstdint.h>
#include <bsl_ostream.h>
#include <bsl_string.h>
#include <bsl_vector.h>
#include <bslma_allocator.h>
#include <bslma_usesbslmaallocator.h>
#include <bslmf_nestedtraitdeclaration.h>
#include <bsls_alignedbuffer.h>
#include <bsls_types.h>
 
namespace BloombergLP {
 
// FORWARD DECLARATION
namespace bmqp {
class MessageProperties;
}
namespace bmqp {
class MessagePropertiesIterator;
}
 
namespace bmqa {
 
// =======================
// class MessageProperties
// =======================
 
class MessageProperties {
    // FRIENDS
    friend class MessagePropertiesIterator;
 
  private:
    // PRIVATE CONSTANTS
 
    static const int k_MAX_SIZEOF_BMQP_MESSAGEPROPERTIES = 184;
 
    // PRIVATE TYPES
    typedef bsls::AlignedBuffer<k_MAX_SIZEOF_BMQP_MESSAGEPROPERTIES>
        ImplBuffer;
 
  private:
    // DATA
 
    mutable bmqp::MessageProperties* d_impl_p;
 
    ImplBuffer d_buffer;
 
    bslma::Allocator* d_allocator_p;
 
  public:
    // PUBLIC CONSTANTS
 
    static const int k_MAX_NUM_PROPERTIES = 255;
 
    static const int k_MAX_PROPERTIES_AREA_LENGTH = (64 * 1024 * 1024) - 8;
 
    static const int k_MAX_PROPERTY_NAME_LENGTH = 4095;
 
    static const int k_MAX_PROPERTY_VALUE_LENGTH = 67104745;
 
  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(MessageProperties,
                                   bslma::UsesBslmaAllocator)
 
    // CREATORS
 
    
    explicit MessageProperties(bslma::Allocator* basicAllocator = 0);
 
    MessageProperties(const MessageProperties& other,
                      bslma::Allocator*        basicAllocator = 0);
 
    ~MessageProperties();
 
    // MANIPULATORS
 
    MessageProperties& operator=(const MessageProperties& rhs);
 
    bool remove(const bsl::string& name, bmqt::PropertyType::Enum* buffer = 0);
 
    void clear();
 
    int setPropertyAsBool(const bsl::string& name, bool value);
    int setPropertyAsChar(const bsl::string& name, char value);
    int setPropertyAsShort(const bsl::string& name, short value);
    int setPropertyAsInt32(const bsl::string& name, bsl::int32_t value);
    int setPropertyAsInt64(const bsl::string& name, bsls::Types::Int64 value);
    int setPropertyAsString(const bsl::string& name, const bsl::string& value);
 
    int setPropertyAsBinary(const bsl::string&       name,
                            const bsl::vector<char>& value);
 
    int streamIn(const bdlbb::Blob& blob);
 
    // ACCESSORS
 
    int numProperties() const;
 
    int totalSize() const;
 
    bool hasProperty(const bsl::string&        name,
                     bmqt::PropertyType::Enum* type = 0) const;
 
    bmqt::PropertyType::Enum propertyType(const bsl::string& name) const;
 
    bool               getPropertyAsBool(const bsl::string& name) const;
    char               getPropertyAsChar(const bsl::string& name) const;
    short              getPropertyAsShort(const bsl::string& name) const;
    bsl::int32_t       getPropertyAsInt32(const bsl::string& name) const;
    bsls::Types::Int64 getPropertyAsInt64(const bsl::string& name) const;
    const bsl::string& getPropertyAsString(const bsl::string& name) const;
 
    const bsl::vector<char>&
    getPropertyAsBinary(const bsl::string& name) const;
 
    bool  getPropertyAsBoolOr(const bsl::string& name, bool value) const;
    char  getPropertyAsCharOr(const bsl::string& name, char value) const;
    short getPropertyAsShortOr(const bsl::string& name, short value) const;
    bsl::int32_t       getPropertyAsInt32Or(const bsl::string& name,
                                            bsl::int32_t       value) const;
    bsls::Types::Int64 getPropertyAsInt64Or(const bsl::string& name,
                                            bsls::Types::Int64 value) const;
    const bsl::string& getPropertyAsStringOr(const bsl::string& name,
                                             const bsl::string& value) const;
 
    const bsl::vector<char>&
    getPropertyAsBinaryOr(const bsl::string&       name,
                          const bsl::vector<char>& value) const;
 
    const bdlbb::Blob&
    streamOut(bdlbb::BlobBufferFactory* bufferFactory) const;
 
    bsl::ostream&
    print(bsl::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};
 
// FREE OPERATORS
 
bsl::ostream& operator<<(bsl::ostream& stream, const MessageProperties& rhs);
 
// ===============================
// class MessagePropertiesIterator
// ===============================
 
class MessagePropertiesIterator {
  private:
    // PRIVATE CONSTANTS
 
    // Constant representing the maximum size of a
    // `bmqp::MessagePropertiesIterator` object, so that the below
    // AlignedBuffer is big enough.
    static const int k_MAX_SIZEOF_BMQP_MESSAGEPROPERTIESITER = 64;
 
    // PRIVATE TYPES
    typedef bsls::AlignedBuffer<k_MAX_SIZEOF_BMQP_MESSAGEPROPERTIESITER>
        ImplBuffer;
 
  private:
    // DATA
    mutable bmqp::MessagePropertiesIterator* d_impl_p;
    // Pointer to the implementation object
    // in 'd_buffer'.  This variable *must*
    // *be* the first member of this class.
    // If the value is null, the object
    // has not been constructed in the
    // 'd_buffer'.
 
    ImplBuffer d_buffer;
    // Buffer containing the implementation
    // object
 
  public:
    // CREATORS
 
    MessagePropertiesIterator();
 
    explicit MessagePropertiesIterator(const MessageProperties* properties);
 
    MessagePropertiesIterator(const MessagePropertiesIterator& other);
 
    ~MessagePropertiesIterator();
 
    // MANIPULATORS
 
    MessagePropertiesIterator& operator=(const MessagePropertiesIterator& rhs);
 
    bool hasNext();
 
    // ACCESSORS
 
    const bsl::string& name() const;
 
    bmqt::PropertyType::Enum type() const;
 
    bool               getAsBool() const;
    char               getAsChar() const;
    short              getAsShort() const;
    bsl::int32_t       getAsInt32() const;
    bsls::Types::Int64 getAsInt64() const;
    const bsl::string& getAsString() const;
 
    const bsl::vector<char>& getAsBinary() const;
};
 
}  // close package namespace
 
// ============================================================================
//                             INLINE DEFINITIONS
// ============================================================================
 
// -----------------------
// class MessageProperties
// -----------------------
 
inline bsl::ostream& bmqa::operator<<(bsl::ostream&                  stream,
                                      const bmqa::MessageProperties& rhs)
{
    return rhs.print(stream, 0, -1);
}
 
}  // close enterprise namespace
 
#endif