zigpc_datastore_accessor.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 ZIGPC_DATASTORE_ACCESSOR_HPP
#define ZIGPC_DATASTORE_ACCESSOR_HPP
 
#include <sstream>
 
// Unify shared includes
#include <sl_status.h>
#include <sl_log.h>
#include <attribute_store.h>
 
// ZigPC includes
#include "zigpc_datastore.h"
#include "zigpc_datastore_id.h"
 
static constexpr char LOG_TAG[] = "zigpc_datastore";
 
template<typename search_key_t, typename data_t> class StoreAccessor
{
  private:
  attribute_store_type_t node_type; 
  std::string label;                
  public:
  explicit StoreAccessor(attribute_store_type_t node_type, std::string label) :
    node_type(node_type), label(label)
  {}
 
  virtual ~StoreAccessor() = default;
 
  inline std::string get_label(void) const
  {
    return label;
  }
 
  inline attribute_store_type_t get_node_type(void) const
  {
    return node_type;
  }
 
  attribute_store_node_t find(attribute_store_node_t parent, search_key_t key)
  {
    auto found_node = ATTRIBUTE_STORE_INVALID_NODE;
    
    std::stringstream ss;
    ss << key;
    std::string key_str = ss.str();
 
    bool input_valid = attribute_store_node_exists(parent);
    if (input_valid == false) {
      sl_log_warning(LOG_TAG,
                     "%s: %s entity[NodeId:%u] Failed to find parent node",
                     this->label.c_str(),
                     key_str.c_str());
    } else {
      found_node = attribute_store_get_node_child_by_value(
        parent,
        this->node_type,
        DESIRED_ATTRIBUTE,
        reinterpret_cast<uint8_t *>(&key),
        sizeof(search_key_t),
        0);
    }
 
    return found_node;
  }
 
  size_t child_count(attribute_store_node_t parent,
                     search_key_t key,
                     attribute_store_type_t child_type)
  {
    size_t child_count = 0U;
 
    attribute_store_node_t found_node = this->find(parent, key);
    if (found_node != ATTRIBUTE_STORE_INVALID_NODE) {
      attribute_store_node_t child_node
        = attribute_store_get_node_child_by_type(found_node,
                                                 child_type,
                                                 child_count);
 
      bool child_valid = !(child_node == ATTRIBUTE_STORE_INVALID_NODE);
      while (child_valid) {
        child_count++;
        child_node  = attribute_store_get_node_child_by_type(found_node,
                                                            child_type,
                                                            child_count);
        child_valid = !(child_node == ATTRIBUTE_STORE_INVALID_NODE);
      }
    }
 
    return child_count;
  }
 
  sl_status_t find_by_index(attribute_store_node_t parent,
                            size_t index,
                            search_key_t *key)
  {
    sl_status_t status = SL_STATUS_OK;
 
    attribute_store_node_t found_child
      = attribute_store_get_node_child_by_type(parent,
                                               this->node_type,
                                               (uint32_t)index);
    if (found_child == ATTRIBUTE_STORE_INVALID_NODE) {
      status = SL_STATUS_NOT_FOUND;
    } else {
      uint8_t child_size(sizeof(search_key_t));
      status = attribute_store_get_node_attribute_value(
        found_child,
        DESIRED_ATTRIBUTE,
        reinterpret_cast<uint8_t *>(key),
        &child_size);
    }
 
    return status;
  }
 
  sl_status_t create(attribute_store_node_t parent, search_key_t key)
  {
    sl_status_t status = SL_STATUS_OK;
    auto found_node    = ATTRIBUTE_STORE_INVALID_NODE;
 
    std::stringstream ss;
    ss << key;
    std::string key_str = ss.str();
 
    found_node = this->find(parent, key);
    if (found_node != ATTRIBUTE_STORE_INVALID_NODE) {
      status = SL_STATUS_ALREADY_EXISTS;
    } else {
      found_node = attribute_store_add_node(this->node_type, parent);
      if (found_node == ATTRIBUTE_STORE_INVALID_NODE) {
        status = SL_STATUS_FAIL;
        sl_log_error(LOG_TAG,
                     "%s: Failed to create entity %s",
                     this->label.c_str(),
                     key_str.c_str());
      }
    }
 
    if (status == SL_STATUS_OK) {
      uint8_t key_size = sizeof(search_key_t);
 
      status = attribute_store_set_node_attribute_value(
        found_node,
        DESIRED_ATTRIBUTE,
        reinterpret_cast<uint8_t *>(&key),
        key_size);
      if (status != SL_STATUS_OK) {
        sl_log_error(LOG_TAG,
                     "%s: %s entity[NodeId:%u]: Failed to populate entity data",
                     this->label.c_str(),
                     key_str.c_str(),
                     found_node);
      }
    }
 
    return status;
  }
 
  sl_status_t
    read(attribute_store_node_t parent, search_key_t key, data_t *const data)
  {
    sl_status_t status = SL_STATUS_OK;
    auto found_node    = ATTRIBUTE_STORE_INVALID_NODE;
 
    if (data == nullptr) {
      status = SL_STATUS_NULL_POINTER;
    } else {
      found_node = this->find(parent, key);
      if (found_node == ATTRIBUTE_STORE_INVALID_NODE) {
        status = SL_STATUS_NOT_FOUND;
      }
    }
 
    if (status == SL_STATUS_OK) {
      uint8_t data_size = sizeof(data_t);
      status            = attribute_store_get_node_attribute_value(
        found_node,
        REPORTED_ATTRIBUTE,
        reinterpret_cast<uint8_t *>(data),
        &data_size);
      if (status != SL_STATUS_OK) {
        std::stringstream ss;
        ss << key;
        std::string key_str = ss.str();
        sl_log_error(LOG_TAG,
                     "%s: %s entity[NodeId:%u]: Failed to read entity data",
                     this->label.c_str(),
                     key_str.c_str(),
                     found_node);
      }
    }
 
    return status;
  }
 
  sl_status_t
    write(attribute_store_node_t parent, search_key_t key, const data_t *data)
  {
    sl_status_t status = SL_STATUS_OK;
    auto found_node    = ATTRIBUTE_STORE_INVALID_NODE;
 
    if (data == nullptr) {
      status = SL_STATUS_NULL_POINTER;
    } else {
      found_node = this->find(parent, key);
      if (found_node == ATTRIBUTE_STORE_INVALID_NODE) {
        status = SL_STATUS_NOT_FOUND;
      }
    }
 
    if (status == SL_STATUS_OK) {
      uint8_t data_size = sizeof(data_t);
      status            = attribute_store_set_node_attribute_value(
        found_node,
        REPORTED_ATTRIBUTE,
        reinterpret_cast<const uint8_t *>(data),
        data_size);
      if (status != SL_STATUS_OK) {
        std::stringstream ss;
        ss << key;
        std::string key_str = ss.str();
        sl_log_error(LOG_TAG,
                     "%s: %s entity[NodeId:%u]: Failed to write entity data",
                     this->label.c_str(),
                     key_str.c_str(),
                     found_node);
      }
    }
 
    return status;
  }
 
  sl_status_t remove(attribute_store_node_t parent, search_key_t key)
  {
    sl_status_t status = SL_STATUS_OK;
 
    std::stringstream ss;
    ss << key;
    std::string key_str = ss.str();
 
    attribute_store_node_t found_node = this->find(parent, key);
 
    if (found_node != ATTRIBUTE_STORE_INVALID_NODE) {
      status = attribute_store_delete_node(found_node);
      if (status != SL_STATUS_OK) {
        sl_log_error(LOG_TAG,
                     "%s: %s entity[NodeId:%u]: Failed to remove entity",
                     this->label.c_str(),
                     key_str.c_str(),
                     found_node);
      }
    } else {
      status = SL_STATUS_NOT_FOUND;
    }
 
    return status;
  }
 
  sl_status_t remove_children(attribute_store_node_t parent, search_key_t key)
  {
    sl_status_t status = SL_STATUS_OK;
 
    attribute_store_node_t found_node = this->find(parent, key);
 
    std::stringstream ss;
    ss << key;
    std::string key_str = ss.str();
    if (found_node == ATTRIBUTE_STORE_INVALID_NODE) {
      status = SL_STATUS_NOT_FOUND;
      sl_log_warning(LOG_TAG,
                     "%s: Failed to find entity %s to remove children under",
                     this->label.c_str(),
                     key_str.c_str());
    } else {
      size_t child_count = attribute_store_get_node_child_count(found_node);
      for (size_t i = 0; i < child_count; i++) {
        attribute_store_node_t child_node
          = attribute_store_get_node_child(found_node, i);
        if (child_node != ATTRIBUTE_STORE_INVALID_NODE) {
          status = attribute_store_delete_node(child_node);
          if (status != SL_STATUS_OK) {
            sl_log_error(LOG_TAG,
                         "%s: Failed to remove child[%u] remove entity",
                         this->label.c_str(),
                         i);
          }
        }
      }
    }
 
    return status;
  }
 
  virtual std::string to_str(attribute_store_node_t parent, search_key_t key)
  {
    std::ostringstream ss;
    data_t data;
 
    sl_status_t status = this->read(parent, key, &data);
    if (status == SL_STATUS_OK) {
      ss << this->label << ": ";
      uint8_t *buffer = reinterpret_cast<uint8_t *>(&data);
      for (size_t i = 0U; i < sizeof(data_t); i++) {
        ss << *buffer << " ";
        buffer++;
      }
    }
 
    return ss.str();
  }
};
 
template<typename list_entry_t> class StoreListAccessor
{
  private:
  StoreAccessor<list_entry_t, uint8_t> list_entry;
 
  public:
  explicit StoreListAccessor(attribute_store_type_t node_type,
                             std::string label) :
    list_entry(node_type, label)
  {}
 
  virtual ~StoreListAccessor() = default;
 
  sl_status_t read_list(attribute_store_node_t list_parent,
                        list_entry_t *const list,
                        size_t list_capacity)
  {
    sl_status_t status = SL_STATUS_OK;
 
    if (list == nullptr) {
      status = SL_STATUS_NULL_POINTER;
    }
    for (size_t i = 0; (status == SL_STATUS_OK) && (i < list_capacity); i++) {
      status = this->list_entry.find_by_index(list_parent, i, list + i);
    }
    return status;
  }
 
  sl_status_t create_list(attribute_store_node_t list_parent,
                          const list_entry_t *list,
                          size_t list_count)
  {
    sl_status_t status = SL_STATUS_OK;
 
    if (list == nullptr) {
      status = SL_STATUS_NULL_POINTER;
    } else {
      // Ensure there is no existing array under the parent by checking if
      // first element exists.
      attribute_store_node_t child_node
        = attribute_store_get_first_child_by_type(
          list_parent,
          this->list_entry.get_node_type());
      if (child_node != ATTRIBUTE_STORE_INVALID_NODE) {
        status = SL_STATUS_ALREADY_EXISTS;
      }
    }
 
    for (size_t i = 0; (status == SL_STATUS_OK) && (i < list_count); i++) {
      status = this->list_entry.create(list_parent, list[i]);
    }
 
    return status;
  }
 
  sl_status_t remove_list(attribute_store_node_t list_parent)
  {
    sl_status_t status = SL_STATUS_OK;
 
    attribute_store_type_t entry_type = this->list_entry.get_node_type();
 
    if (list_parent != ATTRIBUTE_STORE_INVALID_NODE) {
      size_t list_index = 0U;
 
      attribute_store_node_t entry_node
        = attribute_store_get_node_child_by_type(list_parent,
                                                 entry_type,
                                                 list_index);
      while ((status == SL_STATUS_OK)
             && entry_node != ATTRIBUTE_STORE_INVALID_NODE) {
        status = attribute_store_delete_node(entry_node);
        list_index++;
        entry_node = attribute_store_get_node_child_by_type(list_parent,
                                                            entry_type,
                                                            list_index);
      }
    }
 
    return status;
  }
 
  /* Abstract functions that must be implemented */
 
  virtual std::string to_str(attribute_store_node_t parent, size_t list_count)
    = 0;
};
 
/**********************************
 **********************************
 *
 * Accessors used by component
 *
 **********************************
 **********************************/
 
class NetworkAccessor : public StoreAccessor<uint8_t, zigpc_network_data_t>
{
  public:
  explicit NetworkAccessor();
 
  std::string to_str(attribute_store_node_t parent, uint8_t index) override;
};
 
class DeviceAccessor :
  public StoreAccessor<zigbee_eui64_uint_t, zigpc_device_data_t>
{
  public:
  explicit DeviceAccessor();
 
  std::string to_str(attribute_store_node_t parent,
                     zigbee_eui64_uint_t eui64) override;
};
 
class EndpointAccessor :
  public StoreAccessor<zigbee_endpoint_id_t, zigpc_endpoint_data_t>
{
  public:
  explicit EndpointAccessor();
 
  std::string to_str(attribute_store_node_t parent,
                     zigbee_endpoint_id_t endpoint_id) override;
};
 
class GroupAccessor :
    public StoreAccessor<zigbee_group_id_t, zigpc_group_data_t>
{
    private:
        bool is_reported;
 
    public:
        explicit GroupAccessor( bool is_reported); 
  
        static inline std::string get_label_type(bool is_reported)
        {
            return is_reported ? "ReportedGroup" : "DesiredGroup";
        }
        
        static inline attribute_store_type_t
            get_entity_type(bool is_reported)
            {
                return is_reported ? ZIGPC_DS_TYPE_GROUP_REPORTED : ZIGPC_DS_TYPE_GROUP_DESIRED; 
            }
  
        std::string to_str(attribute_store_node_t parent,
                     zigbee_group_id_t group_id) override;
 
 
};
 
class ClusterAccessor :
  public StoreAccessor<zcl_cluster_id_t, zigpc_cluster_data_t>
{
  private:
  zcl_cluster_side_t cluster_side;
 
  public:
  explicit ClusterAccessor(zcl_cluster_side_t cluster_side);
 
  static inline std::string get_label_type(zcl_cluster_side_t cluster_side)
  {
    return (cluster_side == ZCL_CLUSTER_SERVER_SIDE) ? "ServerCluster"
                                                     : "ClientCluster";
  }
 
  static inline attribute_store_type_t
    get_entity_type(zcl_cluster_side_t cluster_side)
  {
    return (cluster_side == ZCL_CLUSTER_SERVER_SIDE)
             ? ZIGPC_DS_TYPE_SERVER_CLUSTER
             : ZIGPC_DS_TYPE_CLIENT_CLUSTER;
  }
 
  std::string to_str(attribute_store_node_t parent,
                     zcl_cluster_id_t cluster_id) override;
};
 
class ClusterAttributeListAccessor :
  public StoreListAccessor<zcl_attribute_id_t>
{
  public:
  explicit ClusterAttributeListAccessor();
 
  static inline std::string get_label_type(void)
  {
    return "Attribute";
  }
 
  std::string to_str(attribute_store_node_t parent, size_t list_count) override;
};
 
class ClusterCommandListAccessor : public StoreListAccessor<zcl_command_id_t>
{
  private:
  zcl_command_type_t command_type;
 
  public:
  explicit ClusterCommandListAccessor(zcl_command_type_t command_type);
 
  static inline std::string get_label_type(zcl_command_type_t command_type)
  {
    return (command_type == ZCL_CLUSTER_GENERATED_COMMAND) ? "GeneratedCommand"
                                                           : "RecievedCommand";
  }
 
  static inline attribute_store_type_t
    get_entity_type(zcl_command_type_t command_type)
  {
    return (command_type == ZCL_CLUSTER_GENERATED_COMMAND)
             ? ZIGPC_DS_TYPE_CLUSTER_GENERATED_COMMAND
             : ZIGPC_DS_TYPE_CLUSTER_RECEIVED_COMMAND;
  }
 
  std::string to_str(attribute_store_node_t parent, size_t list_count) override;
};
 
#endif  //ZIGPC_DATASTORE_ACCESSOR_HPP