attribute.hpp

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2021 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef ATTRIBUTE_HPP
#define ATTRIBUTE_HPP
 
#ifdef __cplusplus
 
#include "attribute_store.h"
#include "attribute_store_helper.h"
#include <vector>
#include <stdexcept>
#include <string>
#include <iterator>
#include <functional>
#include <cstring>
namespace attribute_store
{
template<typename T, typename = void> struct is_iterable : std::false_type {};
template<typename T>
struct is_iterable<T,
                   std::void_t<decltype(std::declval<T>().begin()),
                               decltype(std::declval<T>().end()),
                               decltype(std::declval<T>().push_back(
                                 *(std::declval<T>().begin())))>> :
  std::true_type {};
 
class attribute
{
  public:
  attribute() {};
 
  attribute(attribute_store_node_t n) : _n(n) {};
 
  attribute parent() const
  {
    return attribute_store_get_node_parent(_n);
  }
 
  inline bool get(attribute_store_node_value_state_t value_type,
                  uint8_t *buffer,
                  uint8_t *size) const
  {
    return (SL_STATUS_OK
            == attribute_store_get_node_attribute_value(_n,
                                                        value_type,
                                                        buffer,
                                                        size));
  }
 
  inline attribute
    first_parent_or_self(attribute_store_type_t parent_type) const
  {
    if (type() == parent_type) {
      return *this;
    } else {
      return first_parent(parent_type);
    }
  }
 
  attribute first_parent(attribute_store_type_t type) const
  {
    return attribute_store_get_first_parent_with_type(_n, type);
  }
 
  template<typename T>
  inline T get(attribute_store_node_value_state_t value_type) const
  {
    uint8_t buffer[ATTRIBUTE_STORE_MAXIMUM_VALUE_LENGTH];
    uint8_t size = 0;
    if (get(value_type, (uint8_t *)buffer, &size)) {
      if constexpr(std::is_same<T,std::string>::value) {
        return std::string(reinterpret_cast<char*>(buffer));
      }else if constexpr (is_iterable<T>::value) { // For iterable containers we copy the data
        typedef typename T::value_type v_t;
        //Make sure that value type of the conrainter int,float,bool ... etc
        static_assert(std::is_trivially_copyable<v_t>::value);
        T v;
        v_t *start = reinterpret_cast<v_t *>(buffer);
        v_t *end   = reinterpret_cast<v_t *>(buffer + size);
        std::copy(start, end, std::back_insert_iterator(v));
        return v;
      } else if constexpr (std::is_integral<T>::value) {
        if (size == 1) {
          return *(reinterpret_cast<uint8_t *>(buffer));
        } else if (size == 2) {
          return *(reinterpret_cast<uint16_t *>(buffer));
        }
      } else {
        static_assert(std::is_trivially_copyable<T>::value);
      }
 
      if (size == sizeof(T)) {
        return *(reinterpret_cast<T *>(buffer));
      } else {
        throw std::invalid_argument(
          "Unexpected attribute size for node " + std::to_string(_n)
          + ".Expected: " + std::to_string(sizeof(T))
          + ", actual: " + std::to_string(size)
          + " value state: " + std::to_string(value_type) + ".");
      }
    } else {
      throw std::invalid_argument("Unable to read attribute "
                                  + std::to_string(_n));
    }
  }
 
  inline attribute &set(attribute_store_node_value_state_t value_type,
                        const uint8_t *value,
                        size_t size)
  {
    if (SL_STATUS_OK
        != attribute_store_set_node_attribute_value(_n,
                                                    value_type,
                                                    value,
                                                    size)) {
      throw std::invalid_argument("Unable to write attribute "
                                  + std::to_string(_n));
    } else {
      return *this;
    }
  }
 
  template<typename T>
  inline attribute &set(attribute_store_node_value_state_t value_type, const T& value)
  {
    if constexpr(std::is_same<T,char const*>::value) {
      // We are storing strings as C Strings with the null termination caracter in the attribute store.
      return set(value_type, reinterpret_cast<const uint8_t *>(value), std::strlen(value)+1);
    } else if constexpr(std::is_same<T,std::string>::value) {
      // We are storing strings as C Strings with the null termination caracter in the attribute store.
      return set(value_type, value.c_str());
    } else if constexpr (is_iterable<T>::value) {
      typedef typename T::value_type v_t;
      //Make sure that value type of the conrainter int,float,bool ... etc
      static_assert(std::is_trivially_copyable<v_t>::value);
 
      //The purpose of this is to convert the iterable container into a linear buffer
      std::vector<v_t> v;
      std::copy(value.begin(), value.end(), std::back_insert_iterator(v));
      return set(value_type,
                 reinterpret_cast<const uint8_t *>(v.data()),
                 v.size() * sizeof(v_t));
    }
    else {
      static_assert(std::is_trivially_copyable<T>::value);
      return set(value_type, reinterpret_cast<const uint8_t *>(&value), sizeof(T));
    }
  }
 
 
  inline void clear(attribute_store_node_value_state_t value_type)
  {
    if (SL_STATUS_OK
        != attribute_store_set_node_attribute_value(_n, value_type, 0, 0)) {
      throw std::invalid_argument("Unable to write attribute");
    }
  }
 
  template<typename T> T reported() const
  {
    return get<T>(REPORTED_ATTRIBUTE);
  }
  template<typename T> T desired() const
  {
    return get<T>(DESIRED_ATTRIBUTE);
  }
 
  bool desired_exists()
  {
    return attribute_store_is_value_defined(_n, DESIRED_ATTRIBUTE);
  }
 
  bool reported_exists()
  {
    return attribute_store_is_value_defined(_n, REPORTED_ATTRIBUTE);
  }
 
  template<typename T> T desired_or_reported()
  {
    return get<T>(DESIRED_OR_REPORTED_ATTRIBUTE);
  }
 
  void clear_reported()
  {
    clear(REPORTED_ATTRIBUTE);
  }
 
  void clear_desired()
  {
    clear(DESIRED_ATTRIBUTE);
  }
 
  template<typename T> attribute &set_reported(T v)
  {
    return set<T>(REPORTED_ATTRIBUTE, v);
  }
 
  template<typename T> attribute &set_desired(T v)
  {
    return set<T>(DESIRED_ATTRIBUTE, v);
  }
 
  size_t child_count() const
  {
    return attribute_store_get_node_child_count(_n);
  }
 
  attribute child(size_t index) const
  {
    return attribute_store_get_node_child(_n, index);
  }
 
  attribute child_by_type(attribute_store_type_t type, size_t index = 0) const
  {
    return attribute_store_get_node_child_by_type(_n, type, index);
  }
 
  std::vector<attribute> children() const
  {
    std::vector<attribute> _children;
    size_t n_childs = child_count();
    for (size_t i = 0; i < n_childs; i++) {
      _children.push_back(child(i));
    }
    return _children;
  }
 
  std::vector<attribute> children(attribute_store_type_t type) const
  {
    std::vector<attribute> _children;
    for (size_t i = 0; i < child_count(); i++) {
      if (child(i).type() == type) {
        _children.push_back(child(i));
      }
    }
    return _children;
  }
 
  template<typename T>
  attribute child_by_type_and_value(attribute_store_type_t type, T value) const
  {
    for (auto c: children(type)) {
      if (c.reported_exists() && c.reported<T>() == value) {
        return c;
      }
    }
    return ATTRIBUTE_STORE_INVALID_NODE;
  }
 
  bool is_valid() const
  {
    return attribute_store_node_exists(_n);
  }
 
  attribute_store_type_t type() const
  {
    return attribute_store_get_node_type(_n);
  }
 
  static attribute root()
  {
    return attribute_store_get_root();
  }
 
  attribute add_node(attribute_store_type_t type)
  {
    return attribute_store_add_node(type, _n);
  }
 
  template<typename T>
  attribute emplace_node(attribute_store_type_t type, T val)
  {
    attribute a = child_by_type_and_value(type, val);
    if (a.is_valid()) {
      return a;
    } else {
      return add_node(type).set_reported(val);
    }
  }
 
  attribute emplace_node(attribute_store_type_t type)
  {
    attribute a = child_by_type(type);
    if (a.is_valid()) {
      return a;
    } else {
      return add_node(type);
    }
  }
 
  void delete_node()
  {
    attribute_store_delete_node(_n);
    _n = ATTRIBUTE_STORE_INVALID_NODE;
  }
 
  inline sl_status_t visit(
    const std::function<sl_status_t(attribute_store::attribute &, int)> &func,
    int depth = 0)
  {
    sl_status_t status = func(*this, depth);
    if (SL_STATUS_OK == status) {
      for (auto c: children()) {
        status = c.visit(func, depth + 1);
        if (status == SL_STATUS_ABORT) {
          return status;
        }
      }
    }
    return status;
  }
 
  //type conversion back to attribute_store_node_t
  operator attribute_store_node_t() const
  {
    return _n;
  }
 
  //Comparison operators
  bool operator==(const attribute &a) const
  {
    return _n == a._n;
  }
  bool operator==(attribute_store_node_t a) const
  {
    return _n == a;
  }
 
  private:
  attribute_store_node_t _n = ATTRIBUTE_STORE_INVALID_NODE;
};
 
}  // namespace attribute_store
 
#endif
#endif  //ATTRIBUTE_HPP