AbstractProcessor.hpp

Go to the documentation of this file.

 
#ifndef TPGLIBS_ABSTRACTPROCESSOR_HPP_
#define TPGLIBS_ABSTRACTPROCESSOR_HPP_
 
#include <cstdint>
#include <nlohmann/json.hpp>
#include <memory>
 
#include "tpglibs/ProcessorMetricArray.hpp"
#include "tpglibs/ProcessorInternalStateBufferManager.hpp"
#include "tpglibs/ProcessorInternalStateNameRegistry.hpp"
 
namespace tpglibs {
 
template <class T>
class AbstractProcessor {
  std::shared_ptr<AbstractProcessor<T>> m_next_processor;
 
  protected:
    ProcessorInternalStateBufferManager<T> m_internal_state_buffer_manager;
    ProcessorInternalStateNameRegistry<T> m_internal_state_name_registry;
    
    // Sample counting and collection control
    std::atomic<uint64_t> m_samples{0};
    bool m_collect_internal_state_flag{false};
    uint64_t m_sample_period{1};
 
  public:
    using signal_type_t = T;
 
    virtual ~AbstractProcessor() = default;
 
    ProcessorInternalStateBufferManager<T>* _get_internal_state_buffer_manager() {
      return &m_internal_state_buffer_manager;
    }
 
    ProcessorInternalStateNameRegistry<T>* _get_internal_state_name_registry() {
      return &m_internal_state_name_registry;
    }
 
    virtual void configure_internal_state_collection(const nlohmann::json& config) {
      m_collect_internal_state_flag = config.value("metric_collect_toggle_state", false);
      m_sample_period = config.value("metric_collect_time_sample_period", 1);
      
      if (m_collect_internal_state_flag) {
        if (config.contains("requested_internal_states")) {
          m_internal_state_name_registry.parse_requested_internal_state_items(config["requested_internal_states"]);
        } else {
          m_internal_state_name_registry.parse_requested_internal_state_items("");
        }
        
        // Only configure if we actually have states to collect
        auto num_items = m_internal_state_name_registry.get_number_of_requested_internal_states();
        if (num_items > 0) {
          m_internal_state_buffer_manager.configure_from_registry(&m_internal_state_name_registry);
        }
      }
    }
 
    virtual void configure(const nlohmann::json& config, const int16_t* plane_numbers) = 0;
 
    void set_next_processor(std::shared_ptr<AbstractProcessor<T>> next_processor) {
      m_next_processor = next_processor;
    }
 
    std::shared_ptr<AbstractProcessor<T>> get_next_processor() {
      return m_next_processor;
    }
 
    virtual T process(const T& signal) {
      if (m_next_processor) {
        return m_next_processor->process(signal);
      }
      return signal;
    }
 
    virtual std::vector<std::string> get_requested_internal_state_names() const {
      return m_internal_state_name_registry.get_names_of_requested_internal_states();
    }
 
    virtual ProcessorMetricArray<std::array<int16_t, 16>> read_internal_states_as_integer_array() {
      return m_internal_state_buffer_manager.switch_buffer_and_read_casted();
    }
};
 
} // namespace tpglibs
 
#endif // TPGLIBS_ABSTRACTPROCESSOR_HPP_