ProcessorInternalStateNameRegistry.hpp

Go to the documentation of this file.

 
#include <array>
#include <immintrin.h>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#ifndef TPGLIBS_PROCESSORINTERNALSTATENAMEREGISTRY_HPP_
#define TPGLIBS_PROCESSORINTERNALSTATENAMEREGISTRY_HPP_
 
namespace tpglibs {

template<typename T>
class ProcessorInternalStateNameRegistry
{
public:
  using signal_t = T;

  ProcessorInternalStateNameRegistry() = default;

  ~ProcessorInternalStateNameRegistry();
 
  // Delete copy constructor and copy assignment (registry shouldn't be copied)
  ProcessorInternalStateNameRegistry(const ProcessorInternalStateNameRegistry&) = delete;
  ProcessorInternalStateNameRegistry& operator=(const ProcessorInternalStateNameRegistry&) = delete;
 
  // Allow move semantics for efficiency
  ProcessorInternalStateNameRegistry(ProcessorInternalStateNameRegistry&&) = default;
  ProcessorInternalStateNameRegistry& operator=(ProcessorInternalStateNameRegistry&&) = default;

  size_t get_number_of_requested_internal_states();

  std::vector<std::string> get_names_of_requested_internal_states() const;

  void parse_requested_internal_state_items(std::string config_string);

  void register_internal_state(std::string name, std::shared_ptr<signal_t> pointer_to_state);

  std::shared_ptr<signal_t> get_internal_state_item_ptr(std::string name);

  std::vector<std::shared_ptr<signal_t>> get_all_requested_internal_state_item_ptrs();

  bool is_registered(const std::string& name) const;

  bool is_requested(const std::string& name) const;
 
protected:
  std::vector<std::string> get_all_registered_internal_state_names();

  void clear();
 
public:
// Test interfaces - only for unit testing
#ifdef TPGLIBS_ENABLE_TEST_INTERFACES
  void test_clear() { clear(); }
  std::vector<std::string> test_get_all_registered_internal_state_names()
  {
    return get_all_registered_internal_state_names();
  }
  size_t test_get_map_size() const { return m_internal_state_map.size(); }
#endif
 
private:
  std::unordered_map<std::string, std::shared_ptr<signal_t>> m_internal_state_map;

  std::vector<std::string> m_requested_internal_state_names;
};
 
// Template function implementations
 
template<typename T>
ProcessorInternalStateNameRegistry<T>::~ProcessorInternalStateNameRegistry()
{
  clear();
}
 
template<typename T>
size_t
ProcessorInternalStateNameRegistry<T>::get_number_of_requested_internal_states()
{
  return m_requested_internal_state_names.size();
}
 
template<typename T>
std::vector<std::string>
ProcessorInternalStateNameRegistry<T>::get_names_of_requested_internal_states() const
{
  return m_requested_internal_state_names;
}
 
template<typename T>
void
ProcessorInternalStateNameRegistry<T>::register_internal_state(std::string name,
                                                               std::shared_ptr<signal_t> pointer_to_state)
{
  m_internal_state_map[name] = pointer_to_state;
}
 
template<typename T>
std::shared_ptr<typename ProcessorInternalStateNameRegistry<T>::signal_t>
ProcessorInternalStateNameRegistry<T>::get_internal_state_item_ptr(std::string name)
{
  return m_internal_state_map[name];
}
 
template<typename T>
std::vector<std::string>
ProcessorInternalStateNameRegistry<T>::get_all_registered_internal_state_names()
{
  std::vector<std::string> names;
  for (const auto& item : m_internal_state_map) {
    names.push_back(item.first);
  }
  return names;
}
 
template<typename T>
void
ProcessorInternalStateNameRegistry<T>::parse_requested_internal_state_items(std::string config_string)
{
  // Clear existing requested names first
  m_requested_internal_state_names.clear();
 
  if (config_string.empty()) {
    return;
  }
 
  // Parse comma-separated items
  std::string::size_type start = 0;
  std::string::size_type end = config_string.find(',');
 
  while (end != std::string::npos) {
    // Extract item name and trim whitespace
    std::string item_name = config_string.substr(start, end - start);
 
    // Trim leading and trailing whitespace
    item_name.erase(0, item_name.find_first_not_of(" \t\r\n"));
    item_name.erase(item_name.find_last_not_of(" \t\r\n") + 1);
 
    // Only add non-empty item names
    if (!item_name.empty()) {
      m_requested_internal_state_names.push_back(item_name);
    }
 
    start = end + 1;
    end = config_string.find(',', start);
  }
 
  // Handle the last item (after the final comma or if there are no commas)
  if (start < config_string.length()) {
    std::string last_item = config_string.substr(start);
 
    // Trim leading and trailing whitespace
    last_item.erase(0, last_item.find_first_not_of(" \t\r\n"));
    last_item.erase(last_item.find_last_not_of(" \t\r\n") + 1);
 
    // Only add non-empty item names
    if (!last_item.empty()) {
      m_requested_internal_state_names.push_back(last_item);
    }
  }
}
 
template<typename T>
void
ProcessorInternalStateNameRegistry<T>::clear()
{
  // reinitialize member variables
  m_internal_state_map.clear();
  m_requested_internal_state_names.clear();
}
 
template<typename T>
std::vector<std::shared_ptr<typename ProcessorInternalStateNameRegistry<T>::signal_t>>
ProcessorInternalStateNameRegistry<T>::get_all_requested_internal_state_item_ptrs()
{
  std::vector<std::shared_ptr<typename ProcessorInternalStateNameRegistry<T>::signal_t>> item_ptrs;
  for (const auto& item : m_requested_internal_state_names) {
    item_ptrs.push_back(m_internal_state_map[item]);
  }
  return item_ptrs;
}
 
template<typename T>
bool
ProcessorInternalStateNameRegistry<T>::is_registered(const std::string& name) const
{
  return m_internal_state_map.find(name) != m_internal_state_map.end();
}
 
template<typename T>
bool
ProcessorInternalStateNameRegistry<T>::is_requested(const std::string& name) const
{
  for (const auto& requested_name : m_requested_internal_state_names) {
    if (requested_name == name) {
      return true;
    }
  }
  return false;
}
 
} // namespace tpglibs
 
#endif // TPGLIBS_PROCESSORINTERNALSTATENAMEREGISTRY_HPP_