amqp_value.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "amqp_header.hpp"
 
#include <azure/core/diagnostics/logger.hpp>
#include <azure/core/internal/diagnostics/log.hpp>
#include <azure/core/internal/unique_handle.hpp>
#include <azure/core/uuid.hpp>
 
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <functional>
#include <list>
#include <map>
#include <string>
#include <vector>
 
namespace Azure { namespace Core { namespace Amqp { namespace Models { namespace _detail {
  class AmqpValueImpl;
  class AmqpValueFactory;
}}}}} // namespace Azure::Core::Amqp::Models::_detail
 
namespace Azure { namespace Core { namespace Amqp { namespace Models { namespace _internal {
 
  enum class TerminusDurability : std::uint32_t
  {
    None = 0,
    Configuration = 1,
    UnsettledState = 2,
  };
 
  // Note : Should be an extendable Enumeration.
  enum class TerminusExpiryPolicy
  {
    LinkDetach,
    SessionEnd,
    ConnectionClose,
    Never,
  };
}}}}} // namespace Azure::Core::Amqp::Models::_internal
 
namespace Azure { namespace Core { namespace Amqp { namespace Models {
 
  enum class AmqpValueType
  {
    Invalid,
    Null,
    Bool,
    Ubyte,
    Ushort,
    Uint,
    Ulong,
    Byte,
    Short,
    Int,
    Long,
    Float,
    Double,
    Char,
    Timestamp,
    Uuid,
    Binary,
    String,
    Symbol,
    List,
    Map,
    Array,
    Described,
    Composite,
    Unknown,
  };
 
  std::ostream& operator<<(std::ostream& os, AmqpValueType value);
 
  class AmqpArray;
  class AmqpMap;
  class AmqpList;
  class AmqpBinaryData;
  class AmqpSymbol;
  class AmqpTimestamp;
  class AmqpComposite;
  class AmqpDescribed;
 
  class AmqpValue final {
  public:
    AmqpValue() noexcept;
    ~AmqpValue();
 
    AmqpValue(AmqpValue const& that) noexcept;
 
    AmqpValue(AmqpValue&& that) noexcept;
 
    AmqpValue& operator=(AmqpValue const& that);
    AmqpValue& operator=(AmqpValue&& that) noexcept;
 
    AmqpValue(bool value);
 
    AmqpValue(std::uint8_t value);
 
    AmqpValue(std::uint16_t value);
 
    AmqpValue(std::uint32_t value);
 
    AmqpValue(std::uint64_t value);
 
    AmqpValue(std::int8_t value);
 
    AmqpValue(char value);
 
    AmqpValue(std::int16_t value);
 
    AmqpValue(std::int32_t value);
 
    AmqpValue(std::int64_t value);
 
    AmqpValue(float value);
 
    AmqpValue(double value);
 
    explicit AmqpValue(std::string const& value);
 
    AmqpValue(const char* value);
 
    AmqpValue(char32_t value);
 
    AmqpValue(Azure::Core::Uuid const& value);
 
    bool operator==(AmqpValue const& that) const;
 
    bool operator!=(AmqpValue const& that) const { return !(*this == that); };
 
    bool operator<(AmqpValue const& that) const;
 
    AmqpValueType GetType() const;
 
    bool IsNull() const;
 
    operator bool() const;
 
    operator std::uint8_t() const;
 
    operator std::int8_t() const;
 
    operator char() const;
 
    operator std::uint16_t() const;
 
    operator std::int16_t() const;
 
    operator std::uint32_t() const;
 
    operator std::int32_t() const;
 
    operator std::uint64_t() const;
 
    operator std::int64_t() const;
 
    operator float() const;
 
    operator double() const;
 
    operator char32_t() const;
 
    explicit operator std::string() const;
 
    operator Azure::Core::Uuid() const;
 
    AmqpList AsList() const;
 
    AmqpMap AsMap() const;
 
    AmqpArray AsArray() const;
 
    AmqpBinaryData AsBinary() const;
 
    AmqpTimestamp AsTimestamp() const;
 
    AmqpSymbol AsSymbol() const;
 
    AmqpComposite AsComposite() const;
 
    AmqpDescribed AsDescribed() const;
 
    static std::vector<uint8_t> Serialize(AmqpValue const& value);
 
    static size_t GetSerializedSize(AmqpValue const& value);
 
    static AmqpValue Deserialize(uint8_t const* data, size_t size);
 
  private:
    AmqpValue(std::unique_ptr<Azure::Core::Amqp::Models::_detail::AmqpValueImpl>&& value);
    std::unique_ptr<_detail::AmqpValueImpl> m_impl;
    friend class _detail::AmqpValueFactory;
  };
  std::ostream& operator<<(std::ostream& os, AmqpValue const& value);
 
}}}} // namespace Azure::Core::Amqp::Models
 
namespace Azure { namespace Core { namespace Amqp { namespace Models { namespace _detail {
 
  template <typename T, typename ThisType> class AmqpCollectionBase {
  protected:
    T m_value;
 
    using initializer_type = std::initializer_list<typename T::value_type>;
 
    AmqpCollectionBase(initializer_type const& initializer) : m_value{initializer} {}
    AmqpCollectionBase(T initializer) : m_value{initializer} {}
    AmqpCollectionBase(){};
 
    // Copy constructor
    AmqpCollectionBase(const AmqpCollectionBase& other) = default;
 
    // Copy assignment operator
    AmqpCollectionBase& operator=(const AmqpCollectionBase& other) = default;
 
    // Move constructor
    AmqpCollectionBase(AmqpCollectionBase&& other) noexcept = default;
 
    // Move assignment operator
    AmqpCollectionBase& operator=(AmqpCollectionBase&& other) = default;
 
    ~AmqpCollectionBase() = default;
 
  public:
    explicit operator T const &() const { return m_value; }
 
    AmqpValue AsAmqpValue() const;
 
    inline typename T::size_type size() const { return m_value.size(); }
 
    const typename T::value_type& operator[](const typename T::size_type pos) const noexcept
    {
      return m_value.operator[](pos);
    }
    void push_back(typename T::value_type&& val) { m_value.push_back(std::move(val)); }
    typename T::const_iterator begin() const noexcept { return m_value.begin(); }
    typename T::const_iterator end() const noexcept { return m_value.end(); }
    size_t find(T const& val) noexcept { return m_value.find(val); }
    typename T::value_type* data() noexcept { return m_value.data(); }
    const typename T::value_type* data() const noexcept { return m_value.data(); }
    const typename T::value_type& at(const typename T::size_type pos) const
    {
      return m_value.at(pos);
    }
    bool operator<(ThisType const& that) const { return m_value < that.m_value; }
    bool operator==(ThisType const& that) const { return m_value == that.m_value; }
    bool operator!=(ThisType const& that) const { return m_value != that.m_value; }
    bool empty() const noexcept { return m_value.empty(); }
 
  protected:
    virtual operator _detail::AmqpValueImpl() const;
  };
}}}}} // namespace Azure::Core::Amqp::Models::_detail
 
namespace Azure { namespace Core { namespace Amqp { namespace Models {
  class AmqpArray final : public _detail::AmqpCollectionBase<std::vector<AmqpValue>, AmqpArray> {
  public:
    AmqpArray() : AmqpCollectionBase(){};
 
    AmqpArray(initializer_type const& values);
 
    virtual ~AmqpArray() = default;
 
    AmqpArray(const AmqpArray& other) = default;
 
    AmqpArray& operator=(const AmqpArray& other) = default;
 
    AmqpArray(AmqpArray&& other) noexcept = default;
 
    AmqpArray& operator=(AmqpArray&& other) noexcept = default;
 
    AmqpArray(AmqpValue const& value);
  };
  std::ostream& operator<<(std::ostream& os, AmqpArray const& value);
 
  class AmqpMap final
      : public _detail::AmqpCollectionBase<std::map<AmqpValue, AmqpValue>, AmqpMap> {
 
  public:
    AmqpMap() : AmqpCollectionBase(){};
 
    AmqpMap(std::initializer_list<std::map<AmqpValue, AmqpValue>::value_type> const& values)
        : AmqpCollectionBase(values)
    {
    }
 
    AmqpMap(AmqpMap&& other) noexcept = default;
 
    AmqpMap& operator=(AmqpMap&& other) noexcept = default;
 
    AmqpMap(const AmqpMap& other) = default;
 
    AmqpMap& operator=(const AmqpMap& other) = default;
 
    AmqpMap(AmqpValue const& value);
 
    virtual ~AmqpMap() = default;
 
    decltype(m_value)::mapped_type& operator[](decltype(m_value)::key_type&& keyVal)
    {
      return m_value.operator[](std::move(keyVal));
    }
 
    template <class... ValueTypes>
    std::pair<decltype(m_value)::iterator, bool> emplace(ValueTypes&&... values)
    {
      return m_value.emplace(std::forward<ValueTypes>(values)...);
    }
  };
  std::ostream& operator<<(std::ostream& os, AmqpMap const& value);
 
  class AmqpList final : public _detail::AmqpCollectionBase<std::vector<AmqpValue>, AmqpList> {
  public:
    AmqpList() : AmqpCollectionBase(){};
    virtual ~AmqpList() = default;
    AmqpList(std::initializer_list<std::vector<AmqpValue>::value_type> const& values)
        : AmqpCollectionBase(values)
    {
    }
 
    AmqpList(const AmqpList& other) = default;
 
    AmqpList& operator=(const AmqpList& other) = default;
 
    AmqpList(AmqpList&& other) noexcept = default;
 
    AmqpList& operator=(AmqpList&& other) noexcept = default;
 
    AmqpList(AmqpValue const& value);
  };
  std::ostream& operator<<(std::ostream& os, AmqpList const& value);
 
  class AmqpBinaryData final
      : public _detail::AmqpCollectionBase<std::vector<std::uint8_t>, AmqpBinaryData> {
  public:
    AmqpBinaryData() : AmqpCollectionBase(){};
    virtual ~AmqpBinaryData() = default;
    AmqpBinaryData(initializer_type const& values) : AmqpCollectionBase(values){};
    AmqpBinaryData(std::vector<std::uint8_t> const& values) : AmqpCollectionBase(values){};
 
    AmqpBinaryData(const AmqpBinaryData& other) = default;
 
    AmqpBinaryData& operator=(const AmqpBinaryData& other) = default;
 
    AmqpBinaryData(AmqpBinaryData&& other) noexcept = default;
 
    AmqpBinaryData& operator=(AmqpBinaryData&& other) noexcept = default;
 
    AmqpBinaryData& operator=(std::vector<std::uint8_t> const& values)
    {
      m_value = values;
      return *this;
    };
 
    AmqpBinaryData(AmqpValue const& value);
  };
  std::ostream& operator<<(std::ostream& os, AmqpBinaryData const& value);
 
  class AmqpSymbol final : public _detail::AmqpCollectionBase<std::string, AmqpSymbol> {
  public:
    AmqpSymbol() : AmqpCollectionBase(){};
    virtual ~AmqpSymbol() = default;
 
    AmqpSymbol(std::string const& values) : AmqpCollectionBase(values){};
 
    AmqpSymbol(initializer_type const& initializer) : AmqpCollectionBase(initializer) {}
 
    AmqpSymbol(const char* const values) : AmqpCollectionBase(values){};
 
    AmqpSymbol(const AmqpSymbol& other) = default;
 
    AmqpSymbol& operator=(const AmqpSymbol& other) = default;
 
    AmqpSymbol(AmqpSymbol&& other) noexcept = default;
 
    AmqpSymbol& operator=(AmqpSymbol&& other) noexcept = default;
 
    AmqpSymbol(AmqpValue const& value);
 
    bool operator==(AmqpSymbol const& that) const { return m_value == that.m_value; }
    bool operator==(const decltype(m_value)::value_type* const that) const
    {
      return m_value == that;
    }
  };
  std::ostream& operator<<(std::ostream& os, AmqpSymbol const& value);
 
  class AmqpTimestamp final {
    std::chrono::milliseconds m_value;
 
  public:
    AmqpTimestamp();
    ~AmqpTimestamp() = default;
 
    AmqpTimestamp(std::chrono::milliseconds const& values);
 
    AmqpTimestamp(AmqpValue const& value);
 
    AmqpTimestamp(const AmqpTimestamp& other) = default;
 
    AmqpTimestamp& operator=(const AmqpTimestamp& other) = default;
 
    AmqpTimestamp(AmqpTimestamp&& other) noexcept = default;
 
    AmqpTimestamp& operator=(AmqpTimestamp&& other) noexcept = default;
 
    operator _detail::AmqpValueImpl() const;
 
    AmqpValue AsAmqpValue() const;
 
    operator std::chrono::milliseconds() const { return m_value; }
 
    bool operator<(AmqpTimestamp const& that) { return m_value < that.m_value; }
  };
 
  class AmqpComposite final
      : public _detail::AmqpCollectionBase<std::vector<AmqpValue>, AmqpComposite> {
  public:
    AmqpComposite() : AmqpCollectionBase(){};
    virtual ~AmqpComposite() = default;
 
    AmqpComposite(AmqpValue const& descriptor, std::initializer_list<AmqpValue> const& values);
 
    AmqpComposite(const AmqpComposite& other) = default;
 
    AmqpComposite& operator=(const AmqpComposite& other) = default;
 
    AmqpComposite(AmqpComposite&& other) noexcept = default;
 
    AmqpComposite& operator=(AmqpComposite&& other) noexcept = default;
 
    AmqpComposite(AmqpValue const& value);
 
    bool operator==(AmqpComposite const& that) const
    {
      if (GetDescriptor() == that.GetDescriptor())
      {
        return m_value == that.m_value;
      }
      return false;
    }
 
    bool operator!=(AmqpComposite const& that) const { return !(*this == that); }
 
    AmqpValue const& GetDescriptor() const { return m_descriptor; }
 
  protected:
    operator _detail::AmqpValueImpl() const override;
 
  private:
    AmqpValue m_descriptor;
  };
 
  class AmqpDescribed final {
  public:
    AmqpDescribed(AmqpSymbol const& descriptor, AmqpValue const& value);
 
    AmqpDescribed(AmqpDescribed&& other) noexcept = default;
 
    AmqpDescribed(const AmqpDescribed& other) = default;
 
    AmqpDescribed& operator=(AmqpDescribed&& other) noexcept = default;
 
    AmqpDescribed& operator=(const AmqpDescribed& other) = default;
 
    ~AmqpDescribed() = default;
 
    AmqpDescribed(uint64_t descriptor, AmqpValue const& value);
 
    AmqpDescribed(AmqpValue const& value);
 
    bool operator==(AmqpDescribed const& that) const
    {
      if (GetDescriptor() == that.GetDescriptor())
      {
        return GetValue() == that.GetValue();
      }
      return false;
    }
 
    bool operator!=(AmqpDescribed const& that) const { return !(*this == that); }
    explicit operator AmqpValue const() const;
 
    AmqpValue const& GetDescriptor() const { return m_descriptor; }
 
    AmqpValue const& GetValue() const { return m_value; }
 
    operator _detail::AmqpValueImpl() const;
 
    AmqpValue AsAmqpValue() const;
 
    bool operator<(AmqpDescribed const& that) const
    {
      return m_descriptor < that.m_descriptor ? true
          : m_descriptor == that.m_descriptor ? m_value < that.m_value
                                              : false;
    }
 
  private:
    AmqpValue m_descriptor;
    AmqpValue m_value;
  };
}}}} // namespace Azure::Core::Amqp::Models