Configuration.hpp

Go to the documentation of this file.

 
#ifndef CONFFWK_CONFIGURATION_H_
#define CONFFWK_CONFIGURATION_H_
 
#include <string.h>
 
#include <atomic>
#include <typeinfo>
#include <string>
#include <vector>
#include <list>
#include <set>
 
#include <mutex>
 
#include <boost/property_tree/ptree.hpp>
 
#include "ers/ers.hpp"
 
#include "conffwk/SubscriptionCriteria.hpp"
#include "conffwk/ConfigObject.hpp"
#include "conffwk/ConfigVersion.hpp"
#include "conffwk/Errors.hpp"
#include "conffwk/DalFactory.hpp"
#include "conffwk/DalRegistry.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);
};
 
std::ostream& operator<<(std::ostream& s, const Configuration & c);
 
 
} // namespace conffwk
} // namespace dunedaq
 
#include "details/Configuration.hxx"
 
 
 
 
#endif // CONFFWK_CONFIGURATION_H_