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

 
#ifndef CONFFWK_DAL_OBJECT_H_
#define CONFFWK_DAL_OBJECT_H_
 
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
 
#include "conffwk/Change.hpp"
#include "conffwk/ConfigObject.hpp"
#include "conffwk/Configuration.hpp"
#include "conffwk/DalFactoryFunctions.hpp"
#include "conffwk/DalRegistry.hpp"
#include "conffwk/Errors.hpp"
 
namespace dunedaq {
namespace conffwk {

 
class DalObject
{
 
  friend class Configuration;
  friend class DalFactoryFunctions;
  friend class DalRegistry;
 
  friend std::ostream& operator<<(std::ostream& s, const DalObject* obj);
 
protected:
 
  DalObject(DalRegistry& db, const ConfigObject& o) noexcept
    : p_was_read(false)
    , p_registry(db)
    , p_obj(o)
    , p_UID(p_obj.UID())
  {
    increment_created();
  }
 
  virtual ~DalObject() { ; }

 
  void clear() noexcept { p_obj._clear(); }

 
  void check() const { p_obj.m_impl->throw_if_deleted(); }

 
  bool is_deleted() const { return (p_obj.m_impl->is_deleted()); }
 
protected:
  mutable std::mutex m_mutex;

  bool p_was_read;

  DalRegistry& p_registry;

  ConfigObject p_obj;

  std::string p_UID;
 
public:
 
  const std::string& UID() const noexcept { return p_UID; }

 
  const std::string& class_name() const noexcept { return p_obj.class_name(); }

 
  bool castable(const std::string& target) const noexcept
  {
    return p_registry.configuration().is_superclass_of(target, *p_obj.m_impl->m_class_name);
  }

 
  bool castable(const std::string* target) const noexcept
  {
    return p_registry.configuration().is_superclass_of(target, p_obj.m_impl->m_class_name);
  }

 
  template<class TARGET>
  const TARGET* cast() const noexcept
  {
    // std::lock_guard<std::mutex> scoped_lock(m_mutex);
    // return const_cast<Configuration&>(p_registry).cast<TARGET>(this);
    return dynamic_cast<const TARGET*>(this);
  }

 
  std::string full_name() const noexcept
  {
    std::lock_guard<std::mutex> scoped_lock(m_mutex);
    return (p_UID + '@' + class_name());
  }

 
  const ConfigObject& config_object() const
  {
    std::lock_guard<std::mutex> scoped_lock(m_mutex);
    check();
    return p_obj;
  }

 
  DalRegistry& registry() const noexcept { return p_registry; }

 
  Configuration& configuration() const noexcept { return p_registry.configuration(); }

 
  void unread()
  {
    std::lock_guard<std::mutex> scoped_lock(m_mutex);
    check();
    p_was_read = false;
  }

 
  void set(const ConfigObject& o) noexcept { p_obj = o; }

 
  void move(const std::string& at) { p_obj.move(at); }

 
  void rename(const std::string& new_id) { p_obj.rename(new_id); }
 
  virtual std::vector<const DalObject*> get(const std::string& name, bool upcast_unregistered = true) const = 0;
 
  // helper methods used by generated DALs
 
public:
 
  virtual void print(unsigned int offset, bool print_header, std::ostream& s) const = 0;

  static void p_null(std::ostream& s);

  static void p_rm(std::ostream& s);

  static void p_error(std::ostream& s, dunedaq::conffwk::Exception& ex);

  void p_hdr(std::ostream& s, unsigned int indent, const std::string& cl, const char* nm = nullptr) const;

  std::ostream& print_object(std::ostream& s) const
  {
    if (DalObject::is_null(this)) {
      DalObject::p_null(s);
    } else if (p_obj.m_impl->m_state != dunedaq::conffwk::Valid) {
      DalObject::p_rm(s);
    } else {
      print(0, true, s);
    }
 
    return s;
  }

  void throw_init_ex(dunedaq::conffwk::Exception& ex);

  static void throw_get_ex(const std::string& what, const std::string& class_name, const DalObject* obj);

  static bool is_null(const DalObject* ref) noexcept { return (ref == nullptr); }
 
  // methods for configuration profiler
 
protected:
 
  void increment_created() noexcept
  {
    // ++(p_registry.p_number_of_template_object_created);
  }

 
  void increment_read() noexcept
  {
    // ++(p_registry.p_number_of_template_object_read);
  }
 
private:
  // prevent copy constructor and operator=
  DalObject(const DalObject&) = delete;
  DalObject& operator=(const DalObject&) = delete;
 
  // template<typename T>
  // static void update(Configuration& db, const ConfigurationChange * change) noexcept
  //   {
  //     db.update<T>(change->get_modified_objs(), change->get_removed_objs(), change->get_created_objs());
  //   }
 
  // template<typename T>
  // static void change_id(CacheBase* x, const std::string& old_id, const std::string& new_id) noexcept
  //   {
  //     Configuration::_rename_object<T>(x, old_id, new_id);
  //   }
 
  // template<typename T>
  // static void unread(CacheBase* x) noexcept
  //   {
  //     Configuration::_unread_objects<T>(x);
  //   }
 
  // template<typename T>
  //   static DalObject *
  //   create_instance(Configuration& db, ConfigObject& obj, const std::string& uid)
  //   {
  //     return db._make_instance<T>(obj, uid);
  //   }
 
  // template<typename T>
  //   static DalObject *
  //   new_instance(Configuration& db, ConfigObject& obj)
  //   {
  //     return new T(db, obj);
  //   }
 
protected:
  virtual void init(bool init_children) = 0;

  void check_init() const
  {
    if (!p_was_read) {
      std::lock_guard<std::mutex> scoped_lock(this->p_registry.m_mutex);
      const_cast<DalObject*>(this)->init(false);
    }
  }

  template<typename T>
  void _set_object(const std::string& name, const T* value)
  {
    std::lock_guard<std::mutex> scoped_lock(m_mutex);
    check();
    clear();
    p_obj.set_obj(name, (value ? &value->config_object() : (ConfigObject*)nullptr));
  }

  template<typename T>
  void _set_objects(const std::string& name, const std::vector<const T*>& value)
  {
    std::lock_guard<std::mutex> scoped_lock(m_mutex);
    check();
    clear();
    std::vector<const ConfigObject*> v;
    for (auto& i : value)
      v.push_back(&(i->config_object()));
    p_obj.set_objs(name, v);
  }

  bool get_rel_objects(const std::string& name, bool upcast_unregistered, std::vector<const DalObject*>& objs) const;

  bool get_algo_objects(const std::string& name, std::vector<const DalObject*>& objs) const;
};

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

 
// template<class T>
//   DalFactoryFunctions::DalFactoryFunctions(boost::compute::identity<T>, const std::set<std::string> algorithms) :
//       m_update_fn(DalObject::update<T>),
//       m_creator_fn(DalObject::create_instance<T>),
//       m_instantiator_fn(DalObject::new_instance<T>),
//   {
//     ;
//   }
 
// template<class T>
//   const T *
//   Configuration::create(const DalObject& at, const std::string& id, bool init_object)
//   {
//     return create<T>(at.config_object().contained_in(), id, init_object);
//   }
 
// template<class T>
// Configuration::Cache<T> *
//   Configuration::get_cache() noexcept
//   {
//     CacheBase*& c(m_cache_map[&T::s_class_name]);
 
//     if (c == nullptr)
//       c = new CacheBase(T::s_class_name, DalFactory::instance().functions(*this, T::s_class_name, true));
 
//     return static_cast<Cache<T>*>(c);
//   }
 
// template<class TARGET, class SOURCE>
//   const TARGET *
//   Configuration::cast(const SOURCE *s) noexcept
//   {
//     if (s)
//       {
//         std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
//         ConfigObjectImpl * obj = s->p_obj.m_impl;
 
//         if (try_cast(&TARGET::s_class_name, obj->m_class_name) == true)
//           {
//             std::lock_guard<std::mutex> scoped_lock(obj->m_mutex);
//             if (obj->m_state == dunedaq::conffwk::Valid)
//               return _get<TARGET>(*const_cast<ConfigObject *>(&s->p_obj), s->UID());
//           }
//       }
 
//     return nullptr;
//   }
 
} // namespace conffwk
} // namespace dunedaq
 
#endif // CONFFWK_DAL_OBJECT_H_