smartstart_management.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 SMARTSTART_MANAGEMENT_HPP
#define SMARTSTART_MANAGEMENT_HPP
 
#include <unordered_map>
#include <string>
#include <variant>
#include <functional>
#include <vector>
 
#include "sl_log.h"
#include "sl_status.h"
 
namespace smartstart
{
enum class QueryKey { dsk, include, device_unid };
enum class QueryType { exact, partial };
 
using QueryValue              = std::variant<bool, std::string>;
using notification_function_t = std::function<void(bool)>;
class Query
{
  public:
  QueryType query_type;
  QueryKey query_key;
  QueryValue query_value;
  Query(QueryType type, QueryKey key, const QueryValue &value) :
    query_type {type}, query_key {key}, query_value {value}
  {}
};
 
class Entry
{
  public:
  std::string dsk;
  bool include;
  std::string protocol_controller_unid;
  std::string device_unid;
  std::vector<std::string> preferred_protocols;
  bool manual_intervention_required;
  Entry() = default;
  Entry(const std::string &dsk,
        bool include,
        const std::string &protocol_controller_unid,
        const std::string &device_unid) :
    dsk {dsk},
    include {include},
    protocol_controller_unid {protocol_controller_unid},
    device_unid {device_unid}
  {}
};
 
class Management
{
  private:
  std::unordered_map<std::string, Entry> _smartstart_cache;
 
  std::string _protocol_controller_unid;
 
  notification_function_t _notify_has_entries_awaiting_inclusion;
 
  static Management *_instance;
 
  Management() = default;
 
  public:
  Management(Management &other) = delete;
  void operator=(const Management &) = delete;
  static Management *get_instance();
 
  sl_status_t init(
    const std::string &protocol_controller_unid,
    notification_function_t const &has_entries_awaiting_inclusion_callback);
  sl_status_t teardown();
  std::vector<Entry> get_cache_entries(const Query &query);
  sl_status_t update_smartstart_cache(const std::string &smartstart_list);
 
  bool has_entries_awaiting_inclusion();
 
  sl_status_t notify_node_added(const std::string &dsk,
                                const std::string &device_unid);
  sl_status_t notify_node_removed(const std::string &unid);
 
  sl_status_t
    set_manual_intervention_required(const std::string &dsk,
                                     bool manual_intervention_required);
 
  const std::unordered_map<std::string, Entry> &get_cache() const;
};
 
} /* namespace smartstart */
 
#endif  //SMARTSTART_MANAGEMENT_H