visitor.cpp

Go to the documentation of this file.

 
#include "entity/visitor.h"
 
#include "block/mblock_mul.h"
#include "mode/mode.h"
#include "proto/main.pb.h"
 
namespace entities {
 
 
pb_OverloadStatus_Element& OverloadVisitor::create(){
  auto& elem = m_elements.emplace_back();
  copy_entity(elem.entity);
  return elem;
}
 
void OverloadVisitor::to(pb_OverloadStatus& status){
  status.global_overload = mode::is_global_overload_active();
  status.elements_count = m_elements.size();
  status.elements = new pb_OverloadStatus_Element[status.elements_count];
  std::copy(m_elements.begin(), m_elements.end(), status.elements);
}
 
void OverloadVisitor::handle_visit(Entity* entity) {
  if (entity->is_entity_class(blocks::MMulBlock::CLASS_)) {
    auto *mblock = static_cast<blocks::MBlock *>(entity);
    mblock->collect_overloads(*this);
  }
}
 
class Setup;
 
pb_Config& ExtractVisitor::create(int config_type) const{
  auto& config = m_setup.add_config();
  config.which_kind = config_type;
  config.has_entity = true;
  copy_entity(config.entity);
  return config;
}
 
void Setup::reset() {
  m_configs.clear();
}
 
std::vector<pb_Config>& Setup::configs() {
  return m_configs;
}
 
void Setup::extract(Entity* entity, bool recursive) {
  ExtractVisitor collector(*this);
  collector.visit(entity, recursive);
}
 
void Setup::set(const pb_ConfigBundle &setup) {
  reset();
  extend(setup.configs, setup.configs + setup.configs_count);
}
 
void Setup::get(pb_ConfigBundle &setup) const {
  setup.configs_count = m_configs.size();
  setup.configs = new pb_Config[setup.configs_count];
  std::copy(m_configs.begin(), m_configs.end(), setup.configs);
}
 
 
void Setup::extend(const pb_Config* begin, const pb_Config* end) {
  m_configs.reserve(m_configs.size() + std::distance(begin, end));
  for (auto it = begin ; it != end ; ++it) {
    m_configs.push_back(*it);
  }
}
 
utils::status Setup::apply(Entity* entity, bool write_hardware) const{
  for (auto& config : m_configs) {
    Path path;
    path.push(config.entity.path);
 
    auto resolved_entity = entity->resolve_child_entity(path);
 
    if (!resolved_entity) {
      return utils::status(4, "Could not resolve entity to apply config to");
    }
 
    //empty config
    if (config.which_kind == 0)
      continue;
 
    auto apply_res = resolved_entity->config(config);
    if (apply_res.is_err())
      return utils::status{apply_res.err_value()};
 
    if (!apply_res.ok_value()) {
      LOG4("unhandled config in ", resolved_entity->get_entity_id().c_str(), " with config id ", config.which_kind);
      //config is not beeing applied to anything
      //TODO: has to be handled properly
    }
  }
 
  if (!write_hardware) return {};
  return entity->write_to_hardware();
}
 
pb_Config& Setup::add_config(){
  return m_configs.emplace_back();
}
 
}