ConfigurationImpl.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/ConfigurationImpl.h to include/conffwk/ConfigurationImpl.hpp).
//

 
#ifndef CONFFWK_CONFIGURATIONIMPL_H_
#define CONFFWK_CONFIGURATIONIMPL_H_
 
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
 
#include "conffwk/ConfigVersion.hpp"
#include "conffwk/map.hpp"
#include "conffwk/set.hpp"
 
class ConfigurationChange;
class ConfigObject;
class ConfigObjectImpl;
 
namespace dunedaq {
namespace conffwk {
 
struct class_t;

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

 
  virtual ~ConfigurationImpl();
 
  // methods to open/close database
 
public:
 
  virtual void open_db(const std::string& db_name) = 0;

 
  virtual void close_db() = 0;

 
  virtual bool loaded() const noexcept = 0;

 
  virtual void create(const std::string& db_name, const std::list<std::string>& includes) = 0;

 
  virtual bool is_writable(const std::string& db_name) = 0;

 
  virtual void add_include(const std::string& db_name, const std::string& include) = 0;

 
  virtual void remove_include(const std::string& db_name, const std::string& include) = 0;

 
  virtual void get_includes(const std::string& db_name, std::list<std::string>& includes) const = 0;

 
  virtual void get_updated_dbs(std::list<std::string>& dbs) const = 0;

 
  virtual void set_commit_credentials(const std::string& user, const std::string& password) = 0;

 
  virtual void commit(const std::string& log_message) = 0;

 
  virtual void abort() = 0;

 
  virtual void prefetch_all_data() = 0;

 
  virtual std::vector<dunedaq::conffwk::Version> get_changes() = 0;

 
  virtual std::vector<dunedaq::conffwk::Version> get_versions(const std::string& since,
                                                              const std::string& until,
                                                              dunedaq::conffwk::Version::QueryType type,
                                                              bool skip_irrelevant) = 0;
 
  // methods to get data from database
 
public:
 
  virtual void get(const std::string& class_name,
                   const std::string& id,
                   ConfigObject& object,
                   unsigned long rlevel,
                   const std::vector<std::string>* rclasses) = 0;

 
  virtual void get(const std::string& class_name,
                   std::vector<ConfigObject>& objects,
                   const std::string& query,
                   unsigned long rlevel,
                   const std::vector<std::string>* rclasses) = 0;

 
  virtual void get(const ConfigObject& obj_from,
                   const std::string& query,
                   std::vector<ConfigObject>& objects,
                   unsigned long rlevel,
                   const std::vector<std::string>* rclasses) = 0;

 
  virtual bool test_object(const std::string& class_name,
                           const std::string& id,
                           unsigned long rlevel,
                           const std::vector<std::string>* rclasses) = 0;
 
  // methods to create and destroy objects
 
public:
 
  virtual void create(const std::string& at,
                      const std::string& class_name,
                      const std::string& id,
                      ConfigObject& object) = 0;

 
  virtual void create(const ConfigObject& at,
                      const std::string& class_name,
                      const std::string& id,
                      ConfigObject& object) = 0;

 
  virtual void destroy(ConfigObject& object) = 0;
 
  // get meta-data
 
public:
 
  virtual dunedaq::conffwk::class_t* get(const std::string& class_name, bool direct_only) = 0;

 
  virtual void get_superclasses(conffwk::fmap<conffwk::fset>& schema) = 0;
 
  // notification
 
public:
 
  typedef void (*notify)(std::vector<ConfigurationChange*>& changes, Configuration*);

 
  typedef void (*pre_notify)(Configuration*);

 
  virtual void subscribe(const std::set<std::string>& class_names,
                         const std::map<std::string, std::set<std::string>>& objs,
                         notify cb,
                         pre_notify pre_cb) = 0;

 
  virtual void unsubscribe() = 0;

 
  virtual void print_profiling_info() noexcept = 0;

 
  void print_cache_info() noexcept;

 
private:
  conffwk::pmap<conffwk::map<ConfigObjectImpl*>*> m_impl_objects;
  std::vector<ConfigObjectImpl*> m_tangled_objects; // deleted and replaced by others as result of rename
 
  mutable unsigned long p_number_of_cache_hits;
  mutable unsigned long p_number_of_object_read;
 
protected:
 
  ConfigObjectImpl* get_impl_object(const std::string& class_name, const std::string& id) const noexcept;

 
  void put_impl_object(const std::string& class_name, const std::string& id, ConfigObjectImpl* obj) noexcept;

 
  template<class T, class OBJ>
  T* insert_object(OBJ& obj, const std::string& id, const std::string& class_name) noexcept
  {
    ConfigObjectImpl* p = get_impl_object(class_name, id);
 
    if (p == nullptr) {
      p = static_cast<ConfigObjectImpl*>(new T(obj, this));
      put_impl_object(class_name, id, p);
    } else {
      static_cast<T*>(p)->set(obj);
      p->m_state = dunedaq::conffwk::Valid;
    }
 
    return static_cast<T*>(p);
  }

 
  void clean() noexcept;

 
protected:
  Configuration* m_conf;

 
  std::mutex& get_conf_impl_mutex() const;
 
public:
 
  void set(Configuration* db) noexcept { m_conf = db; }
 
public:
 
  void rename_impl_object(const std::string* class_name, const std::string& old_id, const std::string& new_id) noexcept;
};
 
} // namespace conffwk
} // namespace dunedaq
 
#endif // CONFFWK_CONFIGURATIONIMPL_H_