attribute_store_helper.h

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_STORE_HELPER_H
#define ATTRIBUTE_STORE_HELPER_H
 
// Includes from this component
#include "attribute_store.h"
 
// Generic includes
#include <stdbool.h>
 
// Type that we use to represent "any" number
typedef float number_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
bool attribute_store_is_value_defined(
  attribute_store_node_t node, attribute_store_node_value_state_t value_state);
 
bool attribute_store_is_reported_defined(attribute_store_node_t node);
 
bool attribute_store_is_desired_defined(attribute_store_node_t node);
 
bool attribute_store_is_value_matched(attribute_store_node_t node);
 
sl_status_t
  attribute_store_set_desired_as_reported(attribute_store_node_t node);
 
sl_status_t
  attribute_store_set_reported_as_desired(attribute_store_node_t node);
 
void attribute_store_undefine_reported(attribute_store_node_t node);
 
sl_status_t attribute_store_set_reported(attribute_store_node_t node,
                                         const void *value,
                                         uint8_t value_size);
 
sl_status_t attribute_store_get_reported(attribute_store_node_t node,
                                         void *value,
                                         size_t expected_size);
 
sl_status_t attribute_store_set_reported_number(attribute_store_node_t node,
                                                number_t value);
 
sl_status_t attribute_store_set_desired_number(attribute_store_node_t node,
                                               number_t value);
 
number_t attribute_store_get_reported_number(attribute_store_node_t node);
 
number_t attribute_store_get_desired_number(attribute_store_node_t node);
 
sl_status_t attribute_store_set_reported_string(attribute_store_node_t node,
                                                const char *string);
 
sl_status_t attribute_store_set_desired_string(attribute_store_node_t node,
                                               const char *string);
 
sl_status_t attribute_store_get_reported_string(attribute_store_node_t node,
                                                char *string,
                                                size_t maximum_size);
 
sl_status_t attribute_store_get_desired_string(attribute_store_node_t node,
                                               char *string,
                                               size_t maximum_size);
 
sl_status_t attribute_store_get_desired_else_reported_string(
  attribute_store_node_t node, char *string, size_t maximum_size);
 
sl_status_t
  attribute_store_concatenate_to_reported_string(attribute_store_node_t node,
                                                 const char *string);
 
sl_status_t attribute_store_append_to_reported(attribute_store_node_t node,
                                               const uint8_t *array,
                                               uint8_t extra_array_length);
 
void attribute_store_undefine_desired(attribute_store_node_t node);
 
sl_status_t attribute_store_set_desired(attribute_store_node_t node,
                                        const void *value,
                                        uint8_t value_size);
 
sl_status_t attribute_store_get_desired(attribute_store_node_t node,
                                        void *value,
                                        size_t expected_size);
 
sl_status_t attribute_store_get_desired_else_reported(
  attribute_store_node_t node, void *value, size_t expected_size);
 
sl_status_t
  attribute_store_copy_value(attribute_store_node_t source_node,
                             attribute_store_node_t destination_node,
                             attribute_store_node_value_state_t value_state);
 
sl_status_t
  attribute_store_read_value(attribute_store_node_t node,
                             attribute_store_node_value_state_t value_state,
                             void *read_value,
                             size_t expected_size);
 
sl_status_t attribute_store_set_child_reported(attribute_store_node_t parent,
                                               attribute_store_type_t type,
                                               const void *value,
                                               uint8_t value_size);
 
sl_status_t
  attribute_store_set_all_children_reported(attribute_store_node_t parent,
                                            attribute_store_type_t type,
                                            const void *value,
                                            uint8_t value_size);
 
sl_status_t attribute_store_set_child_desired(attribute_store_node_t parent,
                                              attribute_store_type_t type,
                                              const void *value,
                                              uint8_t value_size);
 
sl_status_t attribute_store_get_child_reported(attribute_store_node_t parent,
                                               attribute_store_type_t type,
                                               void *value,
                                               size_t expected_size);
 
sl_status_t attribute_store_set_child_reported_only_if_missing(
  attribute_store_node_t parent,
  attribute_store_type_t type,
  const void *value,
  uint8_t value_size);
 
sl_status_t attribute_store_set_child_reported_only_if_exists(
  attribute_store_node_t parent,
  attribute_store_type_t type,
  const void *value,
  uint8_t value_size);
 
sl_status_t attribute_store_set_child_reported_only_if_undefined(
  attribute_store_node_t parent,
  attribute_store_type_t type,
  const void *value,
  uint8_t value_size);
 
sl_status_t attribute_store_set_child_desired_only_if_exists(
  attribute_store_node_t parent,
  attribute_store_type_t type,
  const void *value,
  uint8_t value_size);
 
void attribute_store_walk_tree(attribute_store_node_t top,
                               void (*function)(attribute_store_node_t));
 
void attribute_store_walk_tree_with_return_value(
  attribute_store_node_t top, sl_status_t (*function)(attribute_store_node_t));
 
void attribute_store_add_if_missing(attribute_store_node_t parent_node,
                                    const attribute_store_type_t attributes[],
                                    uint32_t count);
 
attribute_store_node_t
  attribute_store_emplace(attribute_store_node_t parent_node,
                          attribute_store_type_t type,
                          const void *value,
                          uint8_t value_size);
 
attribute_store_node_t
  attribute_store_emplace_desired(attribute_store_node_t parent_node,
                                  attribute_store_type_t type,
                                  const void *value,
                                  uint8_t value_size);
 
sl_status_t attribute_store_register_callback_by_type_to_array(
  attribute_store_node_changed_callback_t callback_function,
  const attribute_store_type_t types[],
  uint32_t types_count);
 
sl_status_t attribute_store_delete_all_children(attribute_store_node_t node);
 
attribute_store_node_t
  attribute_store_create_child_if_missing(attribute_store_node_t node,
                                          attribute_store_type_t type);
 
number_t
  attribute_store_get_number(attribute_store_node_t node,
                             attribute_store_node_value_state_t value_state);
 
 
sl_status_t
  attribute_store_set_number(attribute_store_node_t node,
                             number_t value,
                             attribute_store_node_value_state_t value_state);
 
uint8_t attribute_store_get_reported_size(attribute_store_node_t node);
 
uint8_t attribute_store_get_desired_size(attribute_store_node_t node);
 
uint8_t
  attribute_store_get_desired_else_reported_size(attribute_store_node_t node);
 
#ifdef __cplusplus
}
#endif
 
#endif  //attribute_store_helper_H