attribute_mapper_engine.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_MAPPER_ENGINE_H
#define ATTRIBUTE_MAPPER_ENGINE_H
 
#include "attribute.hpp"
#include "attribute_mapper_ast.hpp"
#include "attribute_mapper_ast_dep_eval.hpp"
#include <map>
#include <memory>
 
// Sort priority from high to low.
struct scope_priority_compare {
  bool operator()(const int &lhs, const int &rhs) const
  {
    return lhs > rhs;
  }
};
 
using equivalent_assignments_t = std::
  multimap<int, std::shared_ptr<ast::assignment>, scope_priority_compare>;
 
using assignments_to_run_t
  = std::map<std::tuple<attribute_store::attribute, char, int>,
             equivalent_assignments_t>;
 
using assignment_properties_t = std::tuple<int, char, attribute_store_type_t>;
 
class MapperEngine
{
  public:
  void reset();
 
  bool load_path(const std::string &uam_path);
 
  bool load_file(std::string uam_file_name);
 
  bool add_expression(const std::string expression);
 
  bool update_dependencies(const ast::ast_tree &ast);
 
  bool has_unknown_functions_in_tree(const ast::ast_tree &ast);
 
  void set_common_parent_type(attribute_store_type_t t);
 
  static MapperEngine &get_instance();
 
  void on_attribute_updated(attribute_store_node_t node,
                            attribute_store_node_value_state_t state,
                            attribute_store_change_t change);
 
  private:
  attribute_store::attribute
    get_destination_for_attribute(const attribute_store::attribute &endpoint,
                                  const ast::attribute &attribute,
                                  bool create_if_missing) const;
  equivalent_assignments_t
    get_equivalent_assignments(std::shared_ptr<ast::assignment> assignment);
 
  attribute_store::attribute get_assigment_potential_destination(
    std::shared_ptr<ast::assignment> assignment,
    attribute_store::attribute original_node);
 
  bool
    assignment_matches_destination(std::shared_ptr<ast::assignment> assignment,
                                   attribute_store::attribute destination);
 
  void run_assignments(equivalent_assignments_t assignments_to_check,
                       attribute_store::attribute assigment_destination,
                       attribute_store::attribute original_node);
  bool run_assignment(std::shared_ptr<ast::assignment> assignment,
                      attribute_store::attribute assigment_destination,
                      attribute_store::attribute original_node);
 
  bool
    apply_regular_assignment(attribute_store::attribute common_parent,
                             attribute_store::attribute destination,
                             attribute_store::attribute original_node,
                             const ast::scope_settings_t &settings,
                             result_type_t evaluated_value,
                             std::shared_ptr<ast::assignment> assignment) const;
 
  bool apply_instance_assignment(attribute_store::attribute common_parent,
                                 float evaluated_value,
                                 std::shared_ptr<ast::assignment> assignment,
                                 bool chain_reaction);
 
  bool apply_clearance_assignment(attribute_store::attribute common_parent,
                                  float evaluated_value,
                                  std::shared_ptr<ast::assignment> assignment);
 
  //Lookup table for which assignments depend on which attributes
  std::multimap<ast::attribute_dependency_t, std::shared_ptr<ast::assignment>>
    relations;
 
  /* Saves the scopes settings for an assignment.
     e.g 'scope 2 chain_reaction(0) clear_desired(0) { assignment1 }' will associate
     chain_reaction = 3 and clear_desired = 0 to assignment 1.
  */
  std::map<std::shared_ptr<ast::assignment>,
           std::shared_ptr<ast::scope_settings_t>>
    assignment_settings;
 
  /* Stores properties associated to assignments. */
  std::map<std::shared_ptr<ast::assignment>, assignment_properties_t>
    assignment_properties;
 
  // Default mapper configured comment parent attribute type.
  attribute_store_type_t common_parent_type = ATTRIBUTE_STORE_INVALID_NODE;
};
 
#endif  //ATTRIBUTE_MAPPER_ENGINE_H