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

 
#ifndef CONFFWK_CONFIGURATION_H_
#define CONFFWK_CONFIGURATION_H_
 
#include <string.h>
 
#include <atomic>
#include <list>
#include <set>
#include <string>
#include <typeinfo>
#include <vector>
 
#include <mutex>
 
#include <boost/property_tree/ptree.hpp>
 
#include "ers/ers.hpp"
 
#include "conffwk/ConfigObject.hpp"
#include "conffwk/ConfigVersion.hpp"
#include "conffwk/DalFactory.hpp"
#include "conffwk/DalRegistry.hpp"
#include "conffwk/Errors.hpp"
#include "conffwk/SubscriptionCriteria.hpp"
 
#include "conffwk/map.hpp"
#include "conffwk/set.hpp"
 
namespace dunedaq {
namespace conffwk {
 
class ConfigAction;
class ConfigurationImpl;
class ConfigurationChange;
class DalObject;
class DalRegistry;
 
struct class_t;
 
class Configuration;

 
// class CacheBase
// {
 
//   friend class Configuration;
 
// protected:
 
//   CacheBase(const DalFactoryFunctions& f) :
//       m_functions(f)
//   {
//     ;
//   }
 
//   /** Method for configuration profiling */
 
//   void
//   increment_gets(Configuration& db) noexcept;
 
//   virtual
//   ~CacheBase() noexcept
//   {
//     ;
//   }
 
// protected:
 
//   const DalFactoryFunctions& m_functions;
 
// private:
 
//   conffwk::map<DalObject*> m_cache;
//   conffwk::multimap<DalObject*> m_t_cache;
// };

 
class Configuration
{
 
  friend class DalObject;
  friend class ConfigObject;
  friend class ConfigurationImpl;
  // friend class CacheBase;
  friend class DalObject;
  friend class DalRegistry;
 
public:
 
  Configuration(const std::string& spec);
 
  Configuration();

 
  const std::string& get_impl_spec() const noexcept { return m_impl_spec; }

 
  const std::string& get_impl_name() const noexcept { return m_impl_name; }

 
  const std::string& get_impl_param() const noexcept { return m_impl_param; }

 
  ~Configuration() noexcept;
 
public:
 
  typedef void (*notify)(const std::vector<ConfigurationChange*>& changed_classes, void* parameter);

 
  typedef void (*pre_notify)(void* parameter);
 
private: // Types to be used in public API below
  // structure keeps information about callback subscriptions
 
  struct CallbackSubscription
  {
    notify m_cb;
    void* m_param;
    ConfigurationSubscriptionCriteria m_criteria;
  };
 
  struct CallbackPreSubscription
  {
    pre_notify m_cb;
    void* m_param;
  };
 
public:
 
  typedef CallbackSubscription* CallbackId;

 
  CallbackId subscribe(const ConfigurationSubscriptionCriteria& criteria, notify user_cb, void* user_param = nullptr);

 
  CallbackId subscribe(pre_notify user_cb, void* user_param = nullptr);

 
  void unsubscribe(CallbackId cb_handler = 0);

 
  template<class T>
  bool is_valid(const T* object) noexcept;
 
private:
  void reset_subscription();
 
public:
 
  template<class T>
  void update(const std::vector<std::string>& modified,
              const std::vector<std::string>& removed,
              const std::vector<std::string>& created) noexcept;

 
  void update_cache(std::vector<ConfigurationChange*>& changes) noexcept;

 
  static void system_cb(std::vector<ConfigurationChange*>&, Configuration*) noexcept;

 
  static void system_pre_cb(Configuration*) noexcept;

 
  template<class T>
  void _reset_objects() noexcept;
 
  //   /**
  //    *  \brief Mark object of given template class as unread (multi-thread unsafe).
  //    *
  //    *  Is used by automatically generated data access libraries code after reading parameters for substitution,
  //    *  since cache contains objects with non-substituted attributes. Should not be explicitly used by user.
  //    *
  //    *  The method is used by the unread_all_objects() method.
  //    *  \param  cache_ptr pointer to the cache of template object of given template class (has to be downcasted)
  //    */
 
  // template<class T> static void _unread_objects(CacheBase * cache_ptr) noexcept;
 
  //   /**
  //    *  \brief Rename object of given template class (multi-thread unsafe).
  //    *
  //    *  Is used by automatically generated data access libraries when an object has been renamed by user's code.
  //    *  Should not be explicitly used by user.
  //    *
  //    *  The method is used by the unread_all_objects() method.
  //    *  \param  cache_ptr pointer to the cache of template object of given template class (has to be downcasted)
  //    *  \param  old_id old object ID
  //    *  \param  new_id new object ID
  //    */
 
  // template<class T> static void _rename_object(CacheBase* cache_ptr, const std::string& old_id, const std::string&
  // new_id) noexcept;
 
  //   /**
  //    *  \brief Update state of all objects in cache after abort / commit operations.
  //    *
  //    *  It is used by automatically generated data access libraries.
  //    */
 
  // void _reset_all_objects() noexcept;

 
  void unread_all_objects(bool unread_implementation_objs = false) noexcept;

 
  void unread_template_objects() noexcept
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    _unread_template_objects();
  }

 
  void unread_implementation_objects(dunedaq::conffwk::ObjectState state) noexcept
  {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    _unread_implementation_objects(state);
  }
 
private:
  static void update_impl_objects(conffwk::pmap<conffwk::map<ConfigObjectImpl*>*>& cache,
                                  ConfigurationChange& change,
                                  const std::string* class_name);
 
  void _unread_template_objects() noexcept;
 
  void _unread_implementation_objects(dunedaq::conffwk::ObjectState state) noexcept;
 
public:
 
  void create(const std::string& at, const std::string& class_name, const std::string& id, ConfigObject& object);

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

 
  template<class T>
  const T* create(const std::string& at, const std::string& id, bool init_object = false);

 
  template<class T>
  const T* create(const DalObject& at, const std::string& id, bool init_object = false);

 
  void destroy_obj(ConfigObject& object);

 
  template<class T>
  void destroy(T& obj);
 
public:
 
  bool test_object(const std::string& class_name,
                   const std::string& id,
                   unsigned long rlevel = 0,
                   const std::vector<std::string>* rclasses = 0);

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

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

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

 
  template<class T>
  const T* get(const std::string& id,
               bool init_children = false,
               bool init = true,
               unsigned long rlevel = 0,
               const std::vector<std::string>* rclasses = 0)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _get<T>(id, init_children, init, rlevel, rclasses);
  }

 
  template<class T>
  const T* get(ConfigObject& obj, bool init_children = false, bool init = true)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _get<T>(obj, init_children, init);
  }

 
  template<class T>
  void get(std::vector<const T*>& objects,
           bool init_children = false,
           bool init = true,
           const std::string& query = "",
           unsigned long rlevel = 0,
           const std::vector<std::string>* rclasses = 0)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    _get<T>(objects, init_children, init, query, rlevel, rclasses);
  }

 
  template<class T>
  const T* get(ConfigObject& obj, const std::string& id)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _get<T>(obj, id);
  }

 
  template<class T>
  const T* find(const std::string& id)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _find<T>(id);
  }

 
  template<class T>
  const T* ref(ConfigObject& obj, const std::string& name, bool init = false)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _ref<T>(obj, name, init);
  }

 
  template<class T>
  void ref(ConfigObject& obj, const std::string& name, std::vector<const T*>& objects, bool init = false)
  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    _ref<T>(obj, name, objects, init);
  }

 
  template<class T, class V>
  void referenced_by(const T& obj,
                     std::vector<const V*>& objects,
                     const std::string& relationship_name = "*",
                     bool check_composite_only = true,
                     bool init = false,
                     unsigned long rlevel = 0,
                     const std::vector<std::string>* rclasses = nullptr);

 
  std::vector<const DalObject*> referenced_by(const DalObject& obj,
                                              const std::string& relationship_name = "*",
                                              bool check_composite_only = true,
                                              bool upcast_unregistered = true,
                                              bool init = false,
                                              unsigned long rlevel = 0,
                                              const std::vector<std::string>* rclasses = nullptr);

 
  template<class TARGET, class SOURCE>
  const TARGET* cast(const SOURCE* s) noexcept
  {
    return s->template cast<TARGET>();
  }
 
private:
  void _get(const std::string& class_name,
            const std::string& id,
            ConfigObject& object,
            unsigned long rlevel,
            const std::vector<std::string>* rclasses);

  template<class T>
  const T* _get(const std::string& id,
                bool init_children = false,
                bool init = true,
                unsigned long rlevel = 0,
                const std::vector<std::string>* rclasses = 0);

  template<class T>
  const T* _get(ConfigObject& obj, bool init_children = false, bool init = true);
 
  // /// \throw dunedaq::conffwk::Generic
  // template<class T> const T * _get(ConfigObject& obj, const std::string& id);

  template<class T>
  void _get(std::vector<const T*>& objects,
            bool init_children = false,
            bool init = true,
            const std::string& query = "",
            unsigned long rlevel = 0,
            const std::vector<std::string>* rclasses = 0);

  template<class T>
  DalObject* _make_instance(ConfigObject& obj, const std::string& uid)
  {
    // note upcast since the _get() returns pointer to T
    return const_cast<T*>(_get<T>(obj, uid));
  }
 
  // std::vector<const DalObject*> make_dal_objects(std::vector<ConfigObject>& objs, bool upcast_unregistered);
 
  // const DalObject* make_dal_object(ConfigObject& obj, const std::string& uid, const std::string& class_name);
 
  // should be made private
 
public:
  template<class T>
  void downcast_dal_objects(const std::vector<const T*>& objs,
                            bool /*upcast_unregistered*/,
                            std::vector<const DalObject*>& result)
  {
    for (auto& i : objs)
      result.push_back(i);
  }
 
  template<class T>
  void downcast_dal_object(const T* obj, bool /*upcast_unregistered*/, std::vector<const DalObject*>& result)
  {
    if (obj)
      result.push_back(obj);
  }

 
  template<class T>
  const T* _find(const std::string& id);

 
  template<class T>
  const T* _ref(ConfigObject& obj, const std::string& name, bool read_children);

 
  template<class T>
  void _ref(ConfigObject& obj, const std::string& name, std::vector<const T*>& results, bool read_children);

 
  bool try_cast(const std::string& target, const std::string& source) noexcept;
 
  bool try_cast(const std::string* target, const std::string* source) noexcept;
 
  bool is_superclass_of(const std::string& target, const std::string& source) noexcept;
 
  bool is_superclass_of(const std::string* target, const std::string* source) noexcept;
 
private:
 
  static std::string mk_ref_ex_text(const char* what,
                                    const std::string& cname,
                                    const std::string& rname,
                                    const ConfigObject& obj) noexcept;

 
  static std::string mk_ref_by_ex_text(const std::string& cname,
                                       const std::string& rname,
                                       const ConfigObject& obj) noexcept;
 
  // database manipulations
 
public:
 
  bool loaded() const noexcept;

 
  void load(const std::string& db_name);

 
  void unload();

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

 
  bool is_writable(const std::string& db_name) const;

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

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

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

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

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

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

 
  void abort();

 
  void prefetch_all_data();
 
  // access versions
 
public:
 
  std::vector<dunedaq::conffwk::Version> get_changes();

 
  std::vector<dunedaq::conffwk::Version> get_versions(
    const std::string& since,
    const std::string& until,
    dunedaq::conffwk::Version::QueryType type = dunedaq::conffwk::Version::query_by_date,
    bool skip_irrelevant = true);
 
  // access to schema description
 
public:
 
  const dunedaq::conffwk::class_t& get_class_info(const std::string& class_name, bool direct_only = false);
 
private:
  const dunedaq::conffwk::class_t& _get_class_info(const std::string& class_name, bool direct_only = false);
 
  // cache, storing descriptions of schema
 
  conffwk::map<dunedaq::conffwk::class_t*> p_direct_classes_desc_cache;
  conffwk::map<dunedaq::conffwk::class_t*> p_all_classes_desc_cache;
 
public:
 
  void export_schema(boost::property_tree::ptree& tree, const std::string& classes = "", bool direct_only = false);

 
  void export_data(boost::property_tree::ptree& tree,
                   const std::string& classes = "",
                   const std::string& objects = "",
                   const std::string& files = "",
                   const std::string& empty_array_item = "");
 
  // user-defined converters
 
public:
 
  class AttributeConverterBase
  {
 
  public:
    virtual ~AttributeConverterBase() { ; }
  };

 
  template<class T>
  class AttributeConverter : public AttributeConverterBase
  {
 
  public:
 
    virtual void convert(T& value,
                         const Configuration& conf,
                         const ConfigObject& obj,
                         const std::string& attr_name) = 0;
  };

 
  template<class T>
  void register_converter(AttributeConverter<T>* object) noexcept;

 
  template<class T>
  void convert(T& value, const ConfigObject& obj, const std::string& attr_name) noexcept;

 
  template<class T>
  void convert2(std::vector<T>& value, const ConfigObject& obj, const std::string& attr_name) noexcept;
 
public:
 
  void print_profiling_info() noexcept;
 
private:
  std::atomic<uint_least64_t> p_number_of_cache_hits;
  std::atomic<uint_least64_t> p_number_of_template_object_created;
  std::atomic<uint_least64_t> p_number_of_template_object_read;
 
private:
  conffwk::fmap<conffwk::fset> p_superclasses;
  conffwk::fmap<conffwk::fset> p_subclasses;
  conffwk::fmap<uint> p_class_domain_map;
 
  void set_subclasses() noexcept;
 
  void set_class_domain_map();
 
  void update_classes() noexcept;
 
  std::deque<std::set<std::string>> find_class_domains();
 
public:
 
  const conffwk::fmap<conffwk::fset>& superclasses() const noexcept { return p_superclasses; }

 
  const conffwk::fmap<conffwk::fset>& subclasses() const { return p_subclasses; }
 
  std::vector<std::string> classes_in_python() const;
 
private:
  conffwk::map<std::list<AttributeConverterBase*>*> m_convert_map;
 
  // cache of objects for user-defined classes
 
public:
 
  // template<class T> class Cache : public CacheBase {
 
  //   friend class Configuration;
 
  //   public:
 
  //     Cache() :
  //         CacheBase(DalFactory::instance().functions(T::s_class_name))
  //     {
  //       ;
  //     }
 
  //     virtual ~Cache() noexcept;
 
  //      /**
  //       *  \brief Get template object from cache by conffwk object.
  //       *
  //       *  The method searches an object with id of given conffwk object within the cache.
  //       *  If found, the method sets given conffwk object as implementation of the template
  // *  object and returns pointer on the template object.
  //       *  If there is no such object in cache, then it is created from given conffwk object.
  //       *
  //       *  In case of success, the new object is put into cache and pointer to the object is returned.
  //       *  If there is no such object for given template class, then \b null pointer is returned.
  //       *
  //       *  \param conffwk         the configuration object
  //       *  \param obj            the conffwk object used to set for the template object
  //       *  \param init_children  if true, the referenced objects are initialized (only applicable during creation of
  //       new object)
  //       *  \param init_object    if true, the object's attributes and relationships are read(only applicable during
  //       creation of new object)
  //       *
  //       *  \return Return pointer to object.
  //       *
  //       *  \throw dunedaq::conffwk::Generic is no such class for loaded configuration DB schema or in case of an
  //       error
  //       */
 
  //   T * get(Configuration& conffwk, ConfigObject& obj, bool init_children, bool init_object);
 
  //      /**
  //       *  \brief Get template object from cache by object's ID.
  //       *
  //       *  The method searches an object with given id within the cache.
  //       *  If found, the method returns pointer on it.
  //       *  If there is no such object in cache, there is an attempt to create new object.
  //       *  In case of success, the new object is put into cache and pointer to the object is returned.
  //       *  If there is no such object for given template class, then \b null pointer is returned.
  //       *
  //       *  \param conffwk         the configuration object
  //       *  \param name           object identity
  //       *  \param init_children  if true, the referenced objects are initialized (only applicable during creation of
  //       new object)
  //       *  \param init_object    if true, the object's attributes and relationships are read(only applicable during
  //       creation of new object)
  //       *  \param rlevel         optional references level to optimize performance (defines how many objects
  //       referenced by given object have also to be read to the implementation cache during creation of new object)
  //       *  \param rclasses       optional array of class names to optimize performance (defines which referenced
  //       objects have to be read to the implementation cache during creation of new object)
  //       *
  //       *  \return Return pointer to object. It can be \b null, if there is no such object found.
  //       *
  //       *  \throw dunedaq::conffwk::Generic is no such class for loaded configuration DB schema or in case of an
  //       error
  //       */
 
  //     T * get(Configuration& conffwk, const std::string& name, bool init_children, bool init_object, unsigned long
  //     rlevel, const std::vector<std::string> * rclasses);
 
  //      /**
  //       *  \brief Find template object using ID.
  //       *
  //       *  The method is suitable for generated template objects.
  //       *
  //       *  In case of success, the new object is put into cache and pointer to the object is returned.
  //       *  If there is no such object for given template class, then \b null pointer is returned.
  //       *
  //       *  \param id             ID of generated object
  //       *
  //       *  \return Return pointer to object.
  //       *
  //       *  \throw dunedaq::conffwk::Generic is no such class for loaded configuration DB schema or in case of an
  //       error
  //       */
 
  //     T *
  //     find(const std::string& id);
 
  //      /**
  //       *  \brief Generate template object using conffwk object and ID.
  //       *
  //       *  The method searches an object with id of given conffwk object within the cache using given ID.
  //       *  If found, the method sets given conffwk object as implementation of the template
  //       *  object and returns pointer on the template object.
  //       *  If there is no such object in cache, then it is created from given conffwk object.
  //       *
  //       *  In case of success, the new object is put into cache and pointer to the object is returned.
  //       *  If there is no such object for given template class, then \b null pointer is returned.
  //       *
  //       *  \param conffwk         the configuration object
  //       *  \param obj            the conffwk object used to set for the template object
  //       *  \param id             ID of generated object
  //       *
  //       *  \return Return pointer to object.
  //       *
  //       *  \throw dunedaq::conffwk::Generic is no such class for loaded configuration DB schema or in case of an
  //       error
  //       */
 
  //     T *
  //     get(Configuration& conffwk, ConfigObject& obj, const std::string& id);
 
  // private:
 
  //   conffwk::map<T*> m_cache;
  //   conffwk::multimap<T*> m_t_cache;
 
  // };
 
private:
  // Get cache for this type of objects.
 
  // template<class T> Cache<T> * get_cache() noexcept;
 
  // template<class T> Cache<T> * get_cache( const std::string& class_name ) {
 
  //   const std::string& class_name_ref = DalFactory::instance().get_known_class_name_ref(class_name);
  //   CacheBase*& c(m_cache_map[&class_name_ref]);
 
  //   if (c == nullptr)
  //     // c = new CacheBase(DalFactory::instance().functions(class_name_ref));
  //     c = new CacheBase(class_name_ref, DalFactory::instance().functions(*this, class_name_ref, true));
 
  //   return static_cast<Cache<T>*>(c);
 
  //   // return c;
  // }
 
  // conffwk::fmap<CacheBase*> m_cache_map;
 
  void rename_object(ConfigObject& obj, const std::string& new_id);
 
  // template<class T>
  // void
  // set_cache_unread(const std::vector<std::string>& objects, Cache<T>& c) noexcept
  // {
  //   for (const auto& i : objects)
  //     {
  //       // unread template objects
  //       auto x = c.m_cache.find(i);
  //       if (x != c.m_cache.end())
  //         {
  //           std::lock_guard<std::mutex> scoped_lock(x->second->m_mutex);
  //           x->second->p_was_read = false;
  //         }
 
  //       // unread generated objects if any
  //       auto range = c.m_t_cache.equal_range(i);
  //       for (auto it = range.first; it != range.second; it++)
  //         {
  //           std::lock_guard<std::mutex> scoped_lock(it->second->m_mutex);
  //           it->second->p_was_read = false;
  //         }
  //     }
  // }
 
public:
 
  void print(std::ostream&) const noexcept;
 
  // representation
 
private:
  ConfigurationImpl* m_impl;
  std::string m_impl_spec;
  std::string m_impl_name;
  std::string m_impl_param;
 
  void* m_shlib_h;
 
  // user notification
 
private:
  // user callbacks with parameters
 
  typedef std::set<CallbackSubscription*, std::less<CallbackSubscription*>> CallbackSet;
  typedef std::set<CallbackPreSubscription*, std::less<CallbackPreSubscription*>> PreCallbackSet;
 
  CallbackSet m_callbacks;
  PreCallbackSet m_pre_callbacks;
 
  // method to find callback by handler
 
  CallbackSubscription* find_callback(CallbackId cb_handler) const;
 
public:
  void add_action(ConfigAction* ac);

  void remove_action(ConfigAction* ac);
 
private:
  std::list<ConfigAction*> m_actions;
  void action_on_update(const ConfigObject& obj, const std::string& name);
 
private:
  DalRegistry m_registry;
 
  mutable std::mutex m_impl_mutex; // mutex used to access implementation objects (i.e. ConfigObjectImpl objects)
  mutable std::mutex m_tmpl_mutex; // mutex used to access template objects (i.e. generated DAL)
  mutable std::mutex m_actn_mutex; // mutex is used to access actions
  mutable std::mutex m_else_mutex; // mutex used to access subscription, attribute converter, etc. objects
 
  // prevent copy constructor and operator=
 
private:
  Configuration(const Configuration&);
  Configuration& operator=(const Configuration&);
 
public:
  // JCF, Jan-1-2023: a set of functions written specifically for Python bindings
 
  std::unordered_map<std::string, std::unordered_map<std::string, std::string>> attributes_pybind(
    const std::string& class_name,
    bool all);
  std::vector<std::string> get_class_list() const;
  ConfigObject* create_and_return_obj_pybind(const std::string& at,
                                             const std::string& class_name,
                                             const std::string& id);
  ConfigObject* create_and_return_obj_pybind(const ConfigObject& at,
                                             const std::string& class_name,
                                             const std::string& id);
  ConfigObject* get_obj_pybind(const std::string& class_name, const std::string& id);
  std::vector<ConfigObject>* get_objs_pybind(const std::string& class_name, const std::string& query = "");
  std::unordered_map<std::string, std::unordered_map<std::string, std::string>> relations_pybind(
    const std::string& class_name,
    bool all);
  std::list<std::string>* return_includes_pybind(const std::string& db_name);
  std::vector<std::string> subclasses_pybind(const std::string& class_name, bool all);
  std::vector<std::string> superclasses_pybind(const std::string& class_name, bool all);
  [[nodiscard]] const std::string& get_schema_path_pybind(const std::string& class_name);
};

 
std::ostream&
operator<<(std::ostream& s, const Configuration& c);

 
} // namespace conffwk
} // namespace dunedaq
 
#include "details/Configuration.hxx"
 
#endif // CONFFWK_CONFIGURATION_H_