attribute_map.hpp

#pragma once
 
#include <map>
#include <iomanip>
 
#include "telemetry.hpp"
 
#include "../shims/stdvariant.hpp"
#include "../string.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Telemetry
  {
    using Attribute = variant<bool, int64_t, double, std::string>;


    class AttributeMap
    {
 
    public:
      AttributeMap(const AttributeMap &other) = delete;
      AttributeMap& operator=(const AttributeMap &other) = delete;
      AttributeMap(AttributeMap&& other) noexcept
        : attributes_(std::move(other.attributes_))
      {
        std::swap(handle_, other.handle_);
      }
      AttributeMap& operator=(AttributeMap&& other) noexcept
      {
        if (this != &other)
        {
          attributes_ = std::move(other.attributes_);
          std::swap(handle_, other.handle_);
        }
        return *this;
      }
      virtual ~AttributeMap() = default;
 
      template <class T>
      AttributeMap &operator()(const std::string &key, const T &value);

      AttributeMap &operator()(const std::string &key, const Char *value);

      AttributeMap &operator()(const std::string &key, void *value);
 
      template <class T>
      T Get(const std::string &key) const;


      explicit operator bool() const noexcept
      {
        return handle_ != nullptr;
      }
 
    protected:
      AttributeMap() noexcept {}
 
      void Flush() noexcept
      {
        if (!handle_)
          return;
        try
        {
          std::vector<CExports::CVTAttribute> attributes;
          attributes.reserve(attributes_.size());
 
          for (const auto &item : attributes_)
          {
            const void *data = nullptr;
            auto type        = CExports::CVTAT_Undefined;
            if (holds_alternative<std::string>(item.second))
            {
              data = get<std::string>(item.second).c_str();  // safe raw pointer to the data inside the map (string)
              type = CExports::CVTAT_String;
            }
            else if (holds_alternative<double>(item.second))
            {
              data = &get<double>(item.second);
              type = CExports::CVTAT_Double;
            }
            else if (holds_alternative<bool>(item.second))
            {
              data = &get<bool>(item.second);
              type = CExports::CVTAT_Bool;
            }
            else if (holds_alternative<int64_t>(item.second))
            {
              data = &get<int64_t>(item.second);
              type = CExports::CVTAT_Int64;
            }
            if (!data)
              continue;
            CExports::CVTAttribute attribute;
            attribute.Name = item.first.c_str();
            attribute.Type = type;
            attribute.Data = const_cast<void *>(data);  // NOLINT(cppcoreguidelines-pro-type-const-cast)
            attributes.push_back(attribute);
          }
 
          CExports::CVTAttributeMapStore(handle_, attributes.data(), attributes.size());
        }
        catch (...)
        {
 
        }
      }
 
      void *handle_ = nullptr; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
      std::map<std::string, Attribute> attributes_; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
    };
 
    template <class T>
    T AttributeMap::Get(const std::string &key) const
    {
      auto it = attributes_.find(key);
      if (it != attributes_.end())
      {
        // Check if the type stored in the map matches the requested type
        if (Cvb::holds_alternative<T>(it->second))
        {
          return Cvb::get<T>(it->second);
        }
        else
        {
          throw std::runtime_error("invalid key and type mismatch");
        }
      }
      throw std::out_of_range("Key not found");
    }
 
    inline AttributeMap &AttributeMap::operator()(const std::string &key, void *value)
    {
      std::stringstream stream;
      stream << "0x" << std::setfill('0') << std::setw(sizeof(void *) * 2) << std::hex
             << reinterpret_cast<uint64_t>(value);
      attributes_[key] = stream.str();
      return *this;
    }
 
    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const Telemetry::Attribute &value)
    {
      attributes_[key] = value;
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const double &value)
    {
      attributes_[key] = value;
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const float &value)
    {
      attributes_[key] = static_cast<double>(value);
      return *this;
    }
 
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const Char *value)
    {
      attributes_[key] = Internal::ToUTF8(String(value));
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const String &value)
    {
      attributes_[key] = Internal::ToUTF8(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const bool &value)
    {
      attributes_[key] = value;
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const int8_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const uint8_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const int16_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const uint16_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const int32_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const uint32_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const int64_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }

    template <>
    inline AttributeMap &AttributeMap::operator()(const std::string &key, const uint64_t &value)
    {
      attributes_[key] = static_cast<int64_t>(value);
      return *this;
    }
  }  // namespace Telemetry
 
  CVB_END_INLINE_NS
}  // namespace Cvb