DalObject.hpp

Go to the documentation of this file.

 
#ifndef CONFFWK_DAL_OBJECT_H_
#define CONFFWK_DAL_OBJECT_H_
 
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
 
#include "conffwk/ConfigObject.hpp"
#include "conffwk/Configuration.hpp"
#include "conffwk/Change.hpp"
#include "conffwk/DalFactoryFunctions.hpp"
#include "conffwk/Errors.hpp"
#include "conffwk/DalRegistry.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_