base.cpp

Go to the documentation of this file.

#include "proto/main.pb.h"
 
#include <cstring>
#include <entity/base.h>
#include <entity/visitor.h>
#include <utils/mac.h> // toString(eui64)
 
std::string entities::EntityClassifier::to_string() const {
  return "(class = " + std::to_string(class_) + ", type = " + std::to_string(type) +
         ", version = " + version.to_string() + ", variant = " + std::to_string(variant) + ")";
}
 
bool entities::EntityClassifier::operator==(const EntityClassifier &rhs) const {
  return class_ == rhs.class_ && class_enum == rhs.class_enum && type == rhs.type && version == rhs.version &&
         variant == rhs.variant;
}
 
bool entities::EntityClassifier::operator!=(const EntityClassifier &rhs) const {
  return !(rhs == *this);
}
 
void entities::Entity::set_entity_classifier(EntityClassifier classifier) {
  this->classifier = classifier;
}
 
 
const entities::EntityClassifier &entities::Entity::get_entity_classifier() const { return classifier; }
 
entities::EntityClass entities::Entity::get_entity_class() const { return classifier.class_enum; }
 
uint8_t entities::Entity::get_entity_type() const { return classifier.type; }
 
entities::Version entities::Entity::get_entity_version() const { return classifier.version; }
 
uint8_t entities::Entity::get_entity_variant() const { return classifier.variant; }
 
 
entities::Entity *entities::Entity::resolve_child_entity(const Path& path) {
  auto resolved_entity = this;
  for (auto& segment : path) {
    resolved_entity = resolved_entity->get_child_entity(segment);
    if (!resolved_entity)
      return nullptr;
  }
 
  return resolved_entity;
}
 
 
void entities::Entity::encode_classifier(pb_Entity &out) {
  out.id[0] = '/';
  auto it = get_entity_id().copy(out.id + 1, std::size(out.id) - 2);
  out.id[it + 1] = 0;
 
  auto classifier = get_entity_classifier();
  out.class_ = static_cast<pb_Entity_Class>(classifier.class_);
  out.type = classifier.type;
  out.variant = classifier.variant;
  out.has_version = true;
  classifier.version.to_pb(out.version);
 
  it = utils::toString(get_entity_eui()).copy(out.eui, sizeof(out.eui));
  out.eui[it] = 0;
 
  auto children = get_child_entities();
  auto& idx = out.children_count = 0;
 
  if (children.empty()) {
    out.children = nullptr;
    return;
  }
 
  auto children_classifiers = new pb_Entity[children.size()];
  out.children = children_classifiers;
 
  for (auto &child_ptr : children) {
    if (!child_ptr) continue;
    child_ptr->encode_classifier(children_classifiers[idx++]);
  }
}
 
 
UnitResult entities::Entity::setup(Entity* entity, const pb_ConfigCommand& cmd, pb_ConfigResponse &response) {
#ifdef ANABRID_DEBUG_COMMS
  Serial.println(__PRETTY_FUNCTION__);
#endif
  if (cmd.reset_before) {
    entity->reset(ResetAction::CIRCUIT_RESET | ResetAction::OVERLOAD_RESET);
    (void)entity->write_to_hardware();
  }
 
  if (!cmd.has_module)
    return UnitResult::err("Expected bundle inside Config commandCommand");
 
  Setup setup_helper;
  setup_helper.set(cmd.module);
  return setup_helper.apply(entity);
}
 
 
UnitResult entities::Entity::extract(Entity* entity, const pb_ExtractCommand& cmd, pb_ExtractResponse &response) {
#ifdef ANABRID_DEBUG_COMMS
  Serial.println(__PRETTY_FUNCTION__);
#endif
  if (cmd.has_entity) {
    Path path;
    path.push(cmd.entity.path);
    entity = entity->resolve_child_entity(path);
  }
 
  Setup setup;
  ExtractSettings settings{ cmd.recursive, cmd.specification, cmd.configuration, cmd.calibration};
  setup.extract(entity, settings);
  setup.get(response.module);
  response.has_module = true;
 
  // Save entity path back into response
  return UnitResult::ok();
}
 
UnitResult entities::Entity::reset(Entity *entity, const pb_ResetCommand &msg_in, pb_ResetResponse &msg_out) {
  entities::ResetAction reset_request(0);
 
  // msg_in["foo"] | default_value
  //    is a short way to write
  // msg_in.contains("foo") ? msg_in["foo"].as<bool>() : default_value
 
  msg_out.has_entity = false;
 
  bool keep_calibration = msg_in.keep_calibration | true;
 
  if (!keep_calibration)
    reset_request.val |= entities::ResetAction::CALIBRATION_RESET;
 
  bool overload_reset = msg_in.overload_reset | true;
 
  if (overload_reset)
    reset_request.val |= entities::ResetAction::OVERLOAD_RESET;
  // attention: Overload request always immediately writes to hardware
 
  bool circuit_reset = msg_in.circuit_reset | true;
 
  if (circuit_reset)
    reset_request.val |= entities::ResetAction::CIRCUIT_RESET;
 
  entity->reset(reset_request);
 
  if (msg_in.sync | true) {
    TRY_TRUE(entity->write_to_hardware());
  }
  return UnitResult::ok();
}