ConfigObject.hpp

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS config source for the DUNE DAQ project.
// Fork baseline commit: 67a24e731 (2022-10-27).
// Renamed since fork: yes (from config/ConfigObject.h to include/conffwk/ConfigObject.hpp).
//

 
#ifndef CONFFWK_CONFIGOBJECT_H_
#define CONFFWK_CONFIGOBJECT_H_
 
#include <iostream>
#include <string>
#include <vector>
 
#include <mutex>
 
#include "conffwk/ConfigObjectImpl.hpp"
#include "conffwk/Errors.hpp"
 
namespace dunedaq {
namespace conffwk {
 
class Configuration;

 
class ConfigObject
{
 
  friend class Configuration;
  friend class ConfigurationImpl;
  friend class DalObject;
  friend class DalRegistry;
 
public:
 
  ConfigObject() noexcept;

 
  ConfigObject(const ConfigObject& other) noexcept;

 
  ConfigObject(ConfigObjectImpl* impl) noexcept;

 
  ~ConfigObject() noexcept;

 
  ConfigObject& operator=(const ConfigObject& other) noexcept;

 
  ConfigObject& operator=(ConfigObjectImpl* impl) noexcept;

 
  bool operator==(const ConfigObject& other) const noexcept;
 
  ConfigObject* get_obj_pybind(const std::string& attrname);
 
  template<typename T>
  T get_value_pybind(const std::string& attrname)
  {
    T attrval;
    this->get(attrname, attrval);
    return attrval;
  }
 
  template<typename T>
  std::vector<T> get_list_pybind(const std::string& attrname)
  {
    std::vector<T> attrvals;
    this->get(attrname, attrvals);
    return attrvals;
  }
 
  template<typename T>
  void set_list_pybind(const std::string& attrname, std::vector<T> l)
  {
    this->set_by_ref(attrname, l);
  }
 
  // private:
  //   void set_string_list_generic(ConfigObject& co, const std::string& attrname, std::vector<std::string> data,
  //                   void (ConfigObject::*f)(const std::string&, const std::vector<std::string>&)) {
  //     (co.*f)(attrname, data);
  //   }
 
  // public:
 
  //   void set_string_list
  //   (ConfigObject& co, const std::string& attrname, boost::python::list& l) {
  //     set_string_list_generic(co, attrname, l,
  //                &ConfigObject::set_by_ref<const std::vector<std::string> >);
  //   }
 
  //   void set_enum_list
  //   (ConfigObject& co, const std::string& attrname, boost::python::list& l) {
  //     set_string_list_generic(co, attrname, l, &ConfigObject::set_enum);
  //   }
 
  //   void set_class_list
  //   (ConfigObject& co, const std::string& attrname, boost::python::list& l) {
  //     set_string_list_generic(co, attrname, l, &ConfigObject::set_class);
  //   }
 
  //   void set_date_list
  //   (ConfigObject& co, const std::string& attrname, boost::python::list& l) {
  //     set_string_list_generic(co, attrname, l, &ConfigObject::set_date);
  //   }
 
  //   void set_time_list
  //   (ConfigObject& co, const std::string& attrname, boost::python::list& l) {
  //     set_string_list_generic(co, attrname, l, &ConfigObject::set_time);
  //   }

 
  bool is_null() const noexcept { return (m_impl == nullptr); }

 
  bool is_deleted() const { return (m_impl->is_deleted()); }
 
private:
  void action_on_object_update(Configuration* db, const std::string& name);
 
public:
 
  const std::string& UID() const noexcept { return m_impl->m_id; }

 
  const std::string& class_name() const noexcept { return *m_impl->m_class_name; }

 
  const std::string full_name() const noexcept { return UID() + '@' + class_name(); }

 
  const std::string contained_in() const { return m_impl->contained_in(); }

 
  template<class T>
  void get(const std::string& name, T& value)
  {
    m_impl->get(name, value);
    m_impl->convert(value, *this, name);
  }

 
  bool rel(const std::string& name, std::vector<ConfigObject>& value)
  {
    if (m_impl->rel(name, value)) {
      m_impl->convert(value, *this, name);
      return true;
    }
 
    return false;
  }

 
  void referenced_by(std::vector<ConfigObject>& value,
                     const std::string& relationship_name = "*",
                     bool check_composite_only = true,
                     unsigned long rlevel = 0,
                     const std::vector<std::string>* rclasses = nullptr) const
  {
    m_impl->referenced_by(value, relationship_name, check_composite_only, rlevel, rclasses);
  }

  Configuration* get_configuration() const;

 
  void set_obj(const std::string& name, const ConfigObject* o, bool skip_non_null_check = false)
  {
    m_impl->set(name, o, skip_non_null_check);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_objs(const std::string& name, const std::vector<const ConfigObject*>& o, bool skip_non_null_check = false)
  {
    m_impl->set(name, o, skip_non_null_check);
    action_on_object_update(get_configuration(), name);
  }

 
  template<class T>
  void set_by_val(const std::string& name, T value)
  {
    m_impl->set(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  template<class T>
  void set_by_ref(const std::string& name, T& value)
  {
    m_impl->set(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_enum(const std::string& name, const std::string& value)
  {
    m_impl->set_enum(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_class(const std::string& name, const std::string& value)
  {
    m_impl->set_class(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_date(const std::string& name, const std::string& value)
  {
    m_impl->set_date(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_time(const std::string& name, const std::string& value)
  {
    m_impl->set_time(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_enum(const std::string& name, const std::vector<std::string>& value)
  {
    m_impl->set_enum(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_class(const std::string& name, const std::vector<std::string>& value)
  {
    m_impl->set_class(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_date(const std::string& name, const std::vector<std::string>& value)
  {
    m_impl->set_date(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void set_time(const std::string& name, const std::vector<std::string>& value)
  {
    m_impl->set_time(name, value);
    action_on_object_update(get_configuration(), name);
  }

 
  void move(const std::string& at) { m_impl->move(at); }

 
  void rename(const std::string& new_id);

 
  void print_ptr(std::ostream& s) const noexcept;

 
  void print_ref(std::ostream& s,                
                 Configuration& conf,            
                 const std::string& prefix = "", 
                 bool show_contained_in = false  
  ) const noexcept;

 
  const ConfigObjectImpl* implementation() const noexcept { return m_impl; }
 
private:
  void _clear() noexcept
  {
    if (m_impl) {
      m_impl->clear();
    }
  }
 
private:
  ConfigObjectImpl* m_impl;
};

 
std::ostream&
operator<<(std::ostream&, const ConfigObject*);

 
std::ostream&
operator<<(std::ostream&, const ConfigObject&);
 
} // namespace conffwk
} // namespace dunedaq
 
#endif // CONFFWK_CONFIGOBJECT_H_