amps-python-client 5.3.4.1__zip → 5.3.4.3__zip

amps-python-client-5.3.4.3/src/cpp/include/amps/Buffer.hpp

@@ -0,0 +1,214 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef _BUFFER_H_
+#define _BUFFER_H_
+
+#include <amps/ampsplusplus.hpp>
+
+/// \file Buffer.hpp
+/// \brief Provides AMPS::Buffer, an abstract base class used by the
+/// store implementations in the AMPS client.
+
+namespace AMPS
+{
+
+/// Abstract base class for implementing a buffer to be used by a StoreImpl
+/// for storage of publish messages for possible replay to AMPS.
+  class Buffer
+  {
+  public:
+    struct ByteArray
+    {
+      char*  _data;
+      size_t _len;
+      // If true, the _data buffer is owned and must be deleted
+      bool   _owned;
+
+      ByteArray() : _data(0), _len(0), _owned(false) {}
+
+      ByteArray(char* data_, size_t len_, bool owned_)
+        : _data(data_), _len(len_), _owned(owned_) {}
+
+      ByteArray(const ByteArray& rhs_) : _data(rhs_._data), _len(rhs_._len)
+        , _owned(rhs_._owned)
+      {
+        const_cast<ByteArray&>(rhs_)._owned = false;
+      }
+
+      ~ByteArray()
+      {
+        if (_owned)
+        {
+          delete[] _data;
+        }
+      }
+
+      ByteArray& operator=(const ByteArray& rhs_)
+      {
+        _data = rhs_._data;
+        _len = rhs_._len;
+        _owned = rhs_._owned;
+        const_cast<ByteArray&>(rhs_)._owned = false;
+        return *this;
+      }
+    };
+
+    virtual ~Buffer() {}
+
+    ///
+    /// Get the current size of the Buffer in bytes.
+    /// \return The size in bytes.
+    virtual size_t        getSize() const = 0;
+
+    ///
+    /// Set the size for the buffer.
+    /// \param newSize_ The new size in bytes for the buffer.
+    virtual void          setSize(size_t newSize_) = 0;
+
+    ///
+    /// Get the current position in the buffer.
+    /// \return The position in the buffer.
+    virtual size_t        getPosition() const = 0;
+
+    ///
+    /// Set the buffer postion to a location.
+    /// \param position_ The new buffer position.
+    virtual void          setPosition(size_t position_) = 0;
+
+    ///
+    /// Put a byte into the buffer at the current position and advance.
+    /// \param byte_ The byte to put in the buffer.
+    virtual void          putByte(char byte_) = 0;
+
+    ///
+    /// Get the next byte from the buffer and advance.
+    /// \return The byte at the current position.
+    virtual char          getByte() = 0;
+
+    ///
+    /// Put an unsigned 32-bit int value into the buffer at the current
+    /// position and advance past the end of it.
+    /// \param i_ The unsigned 32-bit int value to write to the buffer.
+    virtual void          putUint32(amps_uint32_t i_) = 0;
+
+    ///
+    /// Get the unsigned 32-bit int value at the current buffer position and
+    /// advance past it.
+    /// \return The unsigned 32-bit int value.
+    virtual amps_uint32_t getUint32() = 0;
+
+    ///
+    /// Put a 32-bit int value into the buffer and advance past it.
+    /// \param i_ The 32-bit int value.
+    virtual void          putInt32(amps_int32_t i_) = 0;
+
+    ///
+    /// Get the 32-bit int value at the current buffer position and advance
+    /// past it.
+    /// \return The 32-bit int value at the current position.
+    virtual amps_int32_t  getInt32() = 0;
+
+    ///
+    /// Put a size_t value into the buffer at the current position and advance
+    /// past it.
+    /// \param s_ The size_t value.
+    virtual void          putSizet(size_t s_) = 0;
+
+    ///
+    /// Get a size_t value at the current buffer position and advance past it.
+    /// \return The size_t value.
+    virtual size_t        getSizet() = 0;
+
+    ///
+    /// Put an amps_uint64_t value into the buffer at the current position and
+    /// advance past it.
+    /// \param ui_ The amps_uint64_t value.
+    virtual void          putUint64(amps_uint64_t ui_) = 0;
+
+    ///
+    /// Get an unsigned 64-bit int value at the current buffer position and
+    /// advance past it.
+    /// \return The amps_uint64_t value.
+    virtual amps_uint64_t getUint64() = 0;
+
+    ///
+    /// Put an amps_int64_t value into the buffer at the current position and
+    /// advance past it.
+    /// \param i_ The amps_int64_t value.
+    virtual void          putInt64(amps_int64_t i_) = 0;
+
+    ///
+    /// Get a 64-bit int value at the current buffer position and
+    /// advance past it.
+    /// \return The amps_int64_t value.
+    virtual amps_int64_t  getInt64() = 0;
+
+    ///
+    /// Put the given length of bytes in data into the buffer at the current
+    /// position and advance past them.
+    /// \param data_ A pointer to the beginning of the bytes to write.
+    /// \param dataLength_ The number of bytes from data_ to write.
+    virtual void          putBytes(const char* data_, size_t dataLength_) = 0;
+
+    ///
+    /// Put the given bytes into the buffer at the current position and advance
+    /// past them.
+    /// \param bytes_ The bytes to write into the buffer.
+    virtual void          putBytes(const ByteArray& bytes_) = 0;
+
+    ///
+    /// Get the given number of bytes from the buffer.
+    /// \param numBytes_ The number of bytes to get from the buffer.
+    /// \return The bytes from the buffer.
+    virtual ByteArray  getBytes(size_t numBytes_) = 0;
+
+    ///
+    /// Copy the given number of bytes from this buffer to the given buffer.
+    /// \param buffer_ The destination for the copied bytes.
+    /// \param numBytes_ The number of bytes to get from the buffer.
+    virtual void copyBytes(char* buffer_, size_t numBytes_) = 0;
+
+    ///
+    /// Set the given number of bytes in the buffer to zero starting at the
+    /// given position.
+    /// \param offset_ The position at which to start setting bytes to 0.
+    /// \param length_ The number of bytes to set to zero.
+    virtual void       zero(size_t offset_, size_t length_) = 0;
+
+    ///
+    /// Move the given number of bytes at the given location to the new location
+    /// Buffer should do this in the most optimal fashion.
+    /// \param destination_ The destination offset to copy the bytes to
+    /// \param source_ The source offset in the buffer to copy from
+    /// \param number_ The number of bytes to move
+    virtual void        copyBytes(size_t destination_, size_t source_,
+                                  size_t number_) = 0;
+  };
+
+} // end namespace AMPS
+
+#endif //_BUFFER_H_
+

amps-python-client-5.3.4.3/src/cpp/include/amps/CompositeMessageBuilder.hpp

@@ -0,0 +1,174 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef _AMPS_COMPOSITEMESSAGEBUILDER_HPP_
+#define _AMPS_COMPOSITEMESSAGEBUILDER_HPP_
+
+#include <string>
+
+namespace AMPS
+{
+  /// Used to create payloads for AMPS composite messages, which are messages with
+  /// a number of parts where each part is a complete message of a specific
+  /// message type.
+  /// For example, a composite message type of "composite-json-binary" may be
+  /// declared on the server that combines a set of JSON headers with
+  /// an opaque binary payload. CompositeMessageBuilder makes it easy to assemble
+  /// this payload.
+  class CompositeMessageBuilder
+  {
+  public:
+    static const size_t DEFAULT_INITIAL_CAPACITY = 16 * 1024;
+    static const size_t PART_HEADER_LENGTH = 4;
+    ///
+    /// Create a new, empty CompositeMessageBuilder.
+    /// \param initialCapacity_ The initial capacity (bytes) for this builder.
+    ///
+    CompositeMessageBuilder(size_t initialCapacity_ =
+                              DEFAULT_INITIAL_CAPACITY);
+
+    ~CompositeMessageBuilder(void);
+    ///
+    /// Appends a message part to this object.
+    /// \param data_ The data to append.
+    /// \returns this object.
+    ///
+    CompositeMessageBuilder& append(const std::string& data_);
+    ///
+    /// Appends a message part to this object.
+    /// \param data_ The data to append.
+    /// \param length_ The length of the data to append.
+    /// \returns this object.
+    ///
+    CompositeMessageBuilder& append(const char* data_, size_t length_);
+
+    ///
+    /// Clears this object. Does not resize or free internal buffer.
+    /// \returns this object.
+    ///
+    CompositeMessageBuilder& clear(void);
+
+    ///
+    /// Returns the composite message's data.
+    /// \returns a pointer to the beginning of the composite message data.
+    ///
+    const char* data(void) const;
+    ///
+    /// Returns the length of the composite message's data.
+    /// \returns the length in bytes of the data comprising this message.
+    ///
+    size_t length(void) const;
+
+  protected:
+    // Not implemented.
+    CompositeMessageBuilder(const CompositeMessageBuilder&);
+    CompositeMessageBuilder& operator=(const CompositeMessageBuilder&);
+  private:
+    void _resize(size_t required_);
+
+    char*       _data;
+    size_t      _position;
+    size_t      _capacity;
+  };
+
+  inline CompositeMessageBuilder::CompositeMessageBuilder(size_t initialCapacity_)
+    : _data(new char[initialCapacity_]),
+      _position(0),
+      _capacity(initialCapacity_)
+  {;}
+
+  inline CompositeMessageBuilder::~CompositeMessageBuilder(void)
+  {
+    delete [] _data;
+    _data = NULL;
+  }
+
+  inline CompositeMessageBuilder&
+  CompositeMessageBuilder::append(const std::string& data_)
+  {
+    size_t length = data_.length();
+    size_t required = _position + length + PART_HEADER_LENGTH;
+    if (_capacity < required)
+    {
+      _resize(required);
+    }
+    char* p = _data + _position;
+    *p++ = (char)((length & 0xFF000000) >> 24);
+    *p++ = (char)((length & 0x00FF0000) >> 16);
+    *p++ = (char)((length & 0x0000FF00) >>  8);
+    *p++ = (char)((length & 0x000000FF)      );
+    memcpy(p, data_.c_str(), length);
+    _position += length + PART_HEADER_LENGTH;
+    return *this;
+  }
+  inline CompositeMessageBuilder&
+  CompositeMessageBuilder::append(const char* data_, size_t length_)
+  {
+    size_t required = _position + length_ + PART_HEADER_LENGTH;
+    if (_capacity < required)
+    {
+      _resize(required);
+    }
+    char* p = _data + _position;
+    *p++ = (char)((length_ & 0xFF000000) >> 24);
+    *p++ = (char)((length_ & 0x00FF0000) >> 16);
+    *p++ = (char)((length_ & 0x0000FF00) >>  8);
+    *p++ = (char)((length_ & 0x000000FF)      );
+    memcpy(p, data_, length_);
+    _position += length_ + PART_HEADER_LENGTH;
+    return *this;
+  }
+  inline const char*
+  CompositeMessageBuilder::data(void) const
+  {
+    return _data;
+  }
+  inline size_t
+  CompositeMessageBuilder::length(void) const
+  {
+    return _position;
+  }
+  inline CompositeMessageBuilder&
+  CompositeMessageBuilder::clear(void)
+  {
+    _position = 0;
+    return *this;
+  }
+  inline void
+  CompositeMessageBuilder::_resize(size_t required_)
+  {
+    if (required_ <= _capacity)
+    {
+      return;
+    }
+    char* newData = new char[required_];
+    memcpy(newData, _data, _position);
+    delete[] _data;
+    _data = newData;
+    _capacity = required_;
+  }
+}
+
+#endif

amps-python-client-5.3.4.3/src/cpp/include/amps/CompositeMessageParser.hpp

@@ -0,0 +1,151 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef _AMPS_COMPOSITEMESSAGEPARSER_HPP_
+#define _AMPS_COMPOSITEMESSAGEPARSER_HPP_
+#include <amps/Field.hpp>
+#include <vector>
+
+namespace AMPS
+{
+  ///
+  /// Used to retrieve individual message parts from AMPS composite messages,
+  /// which are messages where the data contains a number of parts and each part
+  /// is a complete message of a specific message type.
+  /// For example, a composite message type of "composite-json-binary" may be
+  /// declared on the server that combines a set of JSON headers with
+  /// an opaque binary payload. CompositeMessageParser makes it easy to retrieve
+  /// the parts of a composite message from the composite message payload.
+  /// CompositeMessageParser does not make a copy of the underlying data
+  /// parsed: your application must ensure that the underlying data is
+  /// valid while using the CompositeMessageParser.
+  ///
+  class CompositeMessageParser
+  {
+  public:
+    /// Creates a new CompositeMessageParser with 0 valid parts.
+    CompositeMessageParser(void);
+
+    ///
+    /// Parses a composite message, first clearing any existing data in
+    /// the parser. This function is designed to accept an AMPS::Message
+    /// whose data is a composite message. It will also work for any other
+    /// class that implements a getDataRaw(char**, size_t*) that sets the
+    /// provided char* to the start of the payload and the provided
+    /// size_t to the length of the data.
+    /// \param message_ The AMPS::Message whose data is a composite message.
+    /// \returns The number of valid composite message parts found in message_.
+    ///
+    template <class T>
+    size_t parse(const T& message_);
+
+    ///
+    /// Parses a composite message body, first clearing any existing data in
+    /// the parser.
+    /// \param data_ A pointer to the composite message data.
+    /// \param length_ The length, in bytes, of the composite message data at data_.
+    /// \returns The number of valid composite message parts found in message_.
+    ///
+    size_t parse(const char* data_, size_t length_);
+
+    ///
+    /// Returns the number of valid message parts in the message that was last parsed.
+    ///
+    size_t size(void) const;
+
+    ///
+    /// Returns the data of a message part.
+    /// \param index_ The index of the part to retrieve.
+    /// \returns A Message::Field that points to the requested message part's data.
+    ///          If index_ is invalid, a 0-length Message::Field pointing to NULL.
+    ///
+    AMPS::Field getPart(size_t index_) const;
+  private:
+    typedef std::pair<const char*, size_t> PartLocator;
+    typedef std::vector<PartLocator> PartVector;
+    PartVector    _parts;
+  };
+
+  inline CompositeMessageParser::CompositeMessageParser(void)
+  {;}
+
+  template <class T>
+  inline size_t
+  CompositeMessageParser::parse(const T& message_)
+  {
+    const char* data;
+    size_t length;
+    message_.getRawData(&data, &length);
+    return parse(data, length);
+  }
+
+  inline size_t
+  CompositeMessageParser::parse(const char* data_, size_t length_)
+  {
+    _parts.clear();
+    const unsigned char* end = (const unsigned char*) data_ + length_;
+    const unsigned char* p = (const unsigned char*) data_;
+    while ((p + 4) <= end)
+    {
+      size_t partLength = p[0];
+      partLength = partLength << 8 | p[1];
+      partLength = partLength << 8 | p[2];
+      partLength = partLength << 8 | p[3];
+
+      p += 4;
+      if (p + partLength <= end)
+      {
+#ifdef AMPS_USE_EMPLACE
+        _parts.emplace_back(PartLocator((const char*)(p), partLength));
+#else
+        _parts.push_back(PartLocator((const char*)(p), partLength));
+#endif
+      }
+      p += partLength;
+    }
+    return _parts.size();
+  }
+  inline size_t
+  CompositeMessageParser::size(void) const
+  {
+    return _parts.size();
+  }
+  inline AMPS::Field
+  CompositeMessageParser::getPart(size_t index_) const
+  {
+    if (index_ < _parts.size())
+    {
+      const PartLocator& part = _parts[index_];
+      return AMPS::Field(part.first, part.second);
+    }
+    else
+    {
+      return AMPS::Field();
+    }
+  }
+}
+#endif
+
+