ConfigObject.hpp

Go to the documentation of this file.

 
#ifndef CONFFWK_CONFIGOBJECT_H_
#define CONFFWK_CONFIGOBJECT_H_
 
#include <string>
#include <vector>
#include <iostream>
 
#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_