Configuration.hxx

Go to the documentation of this file.

#ifndef __DUNEDAQ_CONFFWK_CONFIGURATION_HXX__
#define __DUNEDAQ_CONFFWK_CONFIGURATION_HXX__
 
#include "conffwk/details/DalRegistry.hxx"
 
namespace dunedaq {
namespace conffwk {
 
template<class T>
const T*
Configuration::create(const std::string& at, const std::string& id, bool init_object)
{
  ConfigObject obj;
 
  std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
  create(at, T::s_class_name, id, obj);
  return m_registry.get<T>(obj, false, init_object);
}
 
template<class T>
void
Configuration::destroy(T& obj)
{
  destroy_obj(const_cast<ConfigObject&>(obj.config_object()));
}
 
// Get object of given class and instantiate the template parameter with it.
template<class T>
const T*
Configuration::_get(const std::string& name,
                    bool init_children,
                    bool init_object,
                    unsigned long rlevel,
                    const std::vector<std::string>* rclasses)
{
  return m_registry.get<T>(name, init_children, init_object, rlevel, rclasses);
}
 
// Instantiate the template parameter using existing conffwk object.
template<class T>
const T*
Configuration::_get(ConfigObject& obj, bool init_children, bool init_object)
{
  return m_registry.get<T>(obj, init_children, init_object);
}
 
// FIXME : not supported, delete
// template<class T>
//   const T *
//   Configuration::_get(ConfigObject& obj, const std::string& id)
//   {
//     return m_registry.get<T>(obj, id);
//   }
 
template<class T>
const T*
Configuration::_find(const std::string& id)
{
  // auto it = m_cache_map.find(&T::s_class_name);
  // return (it != m_cache_map.end() ? static_cast<Cache<T>*>(it->second)->find(id) : nullptr);
  return m_registry.find<T>(id);
}
 
// Get all objects the given class and instantiate a vector of the template parameters object with it.
template<class T>
void
Configuration::_get(std::vector<const T*>& result,
                    bool init_children,
                    bool init_object,
                    const std::string& query,
                    unsigned long rlevel,
                    const std::vector<std::string>* rclasses)
{
  std::vector<ConfigObject> objs;
 
  try {
    get(T::s_class_name, objs, query, rlevel, rclasses);
  } catch (dunedaq::conffwk::NotFound& ex) {
    std::ostringstream text;
    text << "wrong database schema, cannot find class \'" << ex.get_data() << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());
  }
 
  if (!objs.empty()) {
    for (auto& i : objs) {
      result.push_back(this->_get<T>(i, init_children, init_object));
    }
  }
}
 
// Get relation from object and instantiate result with it.
template<class T>
const T*
Configuration::_ref(ConfigObject& obj, const std::string& name, bool read_children)
{
  return m_registry._ref<T>(obj, name, read_children);
  // ConfigObject res;
 
  // try
  //   {
  //     obj.get(name, res);
  //   }
  // catch (dunedaq::conffwk::Generic & ex)
  //   {
  //     throw(dunedaq::conffwk::Generic( ERS_HERE, mk_ref_ex_text("an object", T::s_class_name, name, obj).c_str(), ex
  //     ) );
  //   }
 
  // return ((!res.is_null()) ? get_cache<T>(res.class_name())->get(*this, res, read_children, read_children) :
  // nullptr);
}
 
// Get multiple relations from object and instantiate result with it.
template<class T>
void
Configuration::_ref(ConfigObject& obj, const std::string& name, std::vector<const T*>& results, bool read_children)
{
 
  return m_registry._ref<T>(obj, name, results, read_children);
  // std::vector<ConfigObject> objs;
 
  // results.clear();
 
  // try
  //   {
  //     obj.get(name, objs);
  //     results.reserve(objs.size());
 
  //     for (auto& i : objs)
  //       {
  //         results.push_back(get_cache<T>(i.class_name())->get(*this, i, read_children, read_children));
  //       }
  //   }
  // catch (dunedaq::conffwk::Generic & ex)
  //   {
  //     throw(dunedaq::conffwk::Generic( ERS_HERE, mk_ref_ex_text("objects", T::s_class_name, name, obj).c_str(), ex )
  //     );
  //   }
}
 
template<class T, class V>
void
Configuration::referenced_by(const T& obj,
                             std::vector<const V*>& results,
                             const std::string& relationship_name,
                             bool check_composite_only,
                             bool init,
                             unsigned long rlevel,
                             const std::vector<std::string>* rclasses)
{
  std::vector<ConfigObject> objs;
 
  results.clear();
 
  std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
 
  try {
    obj.p_obj.referenced_by(objs, relationship_name, check_composite_only, rlevel, rclasses);
 
    for (auto& i : objs) {
      if (try_cast(V::s_class_name, i.class_name()) == true) {
        // if (const V * o = get_cache<V>()->get(*this, i, init, init))
        if (const V* o = m_registry.get<V>(i, init, init)) {
          results.push_back(o);
        }
      }
    }
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(
      ERS_HERE, mk_ref_by_ex_text(V::s_class_name, relationship_name, obj.p_obj).c_str(), ex));
  }
}
 
// template<class T>
//   Configuration::Cache<T>::~Cache() noexcept
//   {
//     // delete each object in cache
//     for (const auto& i : m_cache)
//       {
//         delete i.second;
//       }
//   }
 
// template<class T>
//   T *
// Configuration::Cache<T>::get(Configuration& conffwk,
//                              ConfigObject& obj, bool init_children, bool init_object)
//   {
//     DalObject*& dalptr = m_cache[obj.m_impl->m_id];
//     T* result = dynamic_cast<T*>(dalptr);
//     if (dalptr == nullptr)
//       {
//         result = dynamic_cast<T*>(m_functions.m_instantiator_fn(conffwk, obj));
//         if (init_object)
//           {
//             std::lock_guard<std::mutex> scoped_lock(result->m_mutex);
//             result->init(init_children);
//           }
//         dalptr = result;
//       }
//     else if(obj.m_impl != result->p_obj.m_impl)
//       {
//         std::lock_guard<std::mutex> scoped_lock(result->m_mutex);
//         result->set(obj); // update implementation object; to be used in case if the object is re-created
//       }
//     increment_gets(conffwk);
//     return result;
//   }
 
// template<class T>
//   T *
//   Configuration::Cache<T>::find(const std::string& id)
//   {
//     auto it = m_cache.find(id);
//     return (it != m_cache.end() ? dynamic_cast<T*>(it->second) : nullptr);
//   }
 
// template<class T>
//   T *
//   Configuration::Cache<T>::get(Configuration& db, ConfigObject& obj, const std::string& id)
//   {
 
//     DalObject*& dalptr = m_cache[id];
//     T* result = dynamic_cast<T*>(dalptr);
//     if (dalptr == nullptr)
//       {
//         result = dynamic_cast<T*>(m_functions.m_instantiator_fn(db, obj));
//         if (id != obj.UID())
//           {
//             result->p_UID = id;
//             m_t_cache.emplace(obj.UID(), result);
//           }
//         dalptr = result;
//       }
//     else if(obj.m_impl != result->p_obj.m_impl)
//       {
//         std::lock_guard<std::mutex> scoped_lock(result->m_mutex);
//         result->set(obj); // update implementation object; to be used in case if the object is re-created
//       }
//     increment_gets(db);
//     return result;
//   }
 
//   // Get object from cache or create it.
 
// template<class T> T *
// Configuration::Cache<T>::get(Configuration& conffwk, const std::string& name, bool init_children, bool init_object,
// unsigned long rlevel, const std::vector<std::string> * rclasses)
// {
 
//   typename conffwk::map<DalObject*>::iterator i = m_cache.find(name);
//   if(i == m_cache.end()) {
//     try {
//       ConfigObject obj;
//       // class name should be the true cache class name
//       conffwk._get(m_class_name, name, obj, rlevel, rclasses);
//       return get(conffwk, obj, init_children, init_object);
//     }
//     catch(dunedaq::conffwk::NotFound & ex) {
//       if(!strcmp(ex.get_type(), "class")) {
//         std::ostringstream text;
//        text << "wrong database schema, cannot find class \"" << ex.get_data() << '\"';
//        throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());
//       }
//       else {
//         return 0;
//       }
//     }
//   }
//   increment_gets(conffwk);
//   return dynamic_cast<T*>(i->second);
// }
 
template<class T>
bool
Configuration::is_valid(const T* object) noexcept
{
  // std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
 
  // auto j = m_cache_map.find(&T::s_class_name);
 
  // if (j != m_cache_map.end())
  //   {
  //     Cache<T> *c = static_cast<Cache<T>*>(j->second);
 
  //     for (const auto& i : c->m_cache)
  //       {
  //         if (i->second == object)
  //           return true;
  //       }
  //   }
 
  // return false;
 
  return m_registry.is_valid(object);
}
 
template<class T>
void
Configuration::update(const std::vector<std::string>& modified,
                      const std::vector<std::string>& removed,
                      const std::vector<std::string>& created) noexcept
{
  // auto j = m_cache_map.find(&T::s_class_name);
 
  // TLOG_DEBUG(4) << "call for class \'" << T::s_class_name << '\'';
 
  // if (j != m_cache_map.end())
  //   {
  //     Cache<T> *c = static_cast<Cache<T>*>(j->second);
  //     set_cache_unread(removed, *c);
  //     set_cache_unread(created, *c);
  //     set_cache_unread(modified, *c);
  // }
  m_registry.update<T>(modified, removed, created);
}
 
template<class T>
void
Configuration::_reset_objects() noexcept
{
  // auto j = m_cache_map.find(&T::s_class_name);
 
  // if (j != m_cache_map.end())
  //   {
  //     _unread_objects(static_cast<Cache<T>*>(j->second));
  //   }
  m_registry._reset_objects<T>();
}
 
// // FIXME: Delete ME
// template<class T>
//   void
//   Configuration::_unread_objects(CacheBase* x) noexcept
//   {
//     Cache<T> *c = static_cast<Cache<T>*>(x);
 
//     for (auto& i : c->m_cache)
//       {
//         i.second->p_was_read = false;
//       }
//   }
 
// // FIXME: Delete ME
// template<class T> void
// Configuration::_rename_object(CacheBase* x, const std::string& old_id, const std::string& new_id) noexcept
// {
//   Cache<T> *c = static_cast<Cache<T>*>(x);
 
//   // rename template object
//   auto it = c->m_cache.find(old_id);
//   if (it != c->m_cache.end())
//     {
//       TLOG_DEBUG(3) << " * rename \'" << old_id << "\' to \'" << new_id << "\' in class \'" << T::s_class_name <<
//       "\')"; c->m_cache[new_id] = it->second; c->m_cache.erase(it);
 
//       std::lock_guard<std::mutex> scoped_lock(it->second->m_mutex);
//       it->second->p_UID = new_id;
//     }
 
//   // rename generated objects if any
//   auto range = c->m_t_cache.equal_range(old_id);
//   for (auto it = range.first; it != range.second;)
//     {
//       T * o = dynamic_cast<T*>(it->second);
//       it = c->m_t_cache.erase(it);
//       c->m_t_cache.emplace(new_id, o);
//     }
// }
 
template<class T>
void
Configuration::register_converter(AttributeConverter<T>* object) noexcept
{
  std::lock_guard<std::mutex> scoped_lock(m_else_mutex);
 
  std::list<AttributeConverterBase*>* c = m_convert_map[typeid(T).name()];
  if (c == 0) {
    c = m_convert_map[typeid(T).name()] = new std::list<AttributeConverterBase*>();
  }
 
  c->push_back(object);
}
 
template<class T>
void
Configuration::convert(T& value, const ConfigObject& obj, const std::string& attr_name) noexcept
{
  conffwk::map<std::list<AttributeConverterBase*>*>::const_iterator l = m_convert_map.find(typeid(T).name());
  if (l != m_convert_map.end()) {
    for (const auto& i : *l->second) {
      static_cast<AttributeConverter<T>*>(i)->convert(value, *this, obj, attr_name);
    }
  }
}
 
template<class T>
void
Configuration::convert2(std::vector<T>& value, const ConfigObject& obj, const std::string& attr_name) noexcept
{
  conffwk::map<std::list<AttributeConverterBase*>*>::const_iterator l = m_convert_map.find(typeid(T).name());
  if (l != m_convert_map.end()) {
    for (auto& j : value) {
      for (const auto& i : *l->second) {
        static_cast<AttributeConverter<T>*>(i)->convert(j, *this, obj, attr_name);
      }
    }
  }
}
 
// inline void
// CacheBase::increment_gets(Configuration& db) noexcept
// {
//   ++db.p_number_of_cache_hits;
// }
 
} // namespace conffwk
} // namespace dunedaq
 
#endif /*__DUNEDAQ_CONFFWK_CONFIGURATION_HXX__ */