dunedaq::conffwk::DalRegistry Class Reference

DalRegistry: A registry of DalObjects It provides a single interface to create, cache and manage DalObjecs. More...

#include <DalRegistry.hpp>

Collaboration diagram for dunedaq::conffwk::DalRegistry:

Classes
struct	DalDomain

Public Member Functions
	DalRegistry (Configuration &confdb)
	Construct a new Dal Registry object.
	~DalRegistry ()
Configuration &	configuration ()
const Configuration &	configuration () const
void	clear ()
	Clear the content of the registy.
DalObject *	get (ConfigObject &obj, bool upcast_unregistered=false)
std::vector< const DalObject * >	get (std::vector< ConfigObject > &objs, bool upcast_unregistered=false)
template<class T >
T *	get (ConfigObject &obj, bool init_children=false, bool init_object=true)
	Get template object from cache by conffwk object.
template<class T >
T *	get (const std::string &name, bool init_children=false, bool init_object=true, unsigned long rlevel=0, const std::vector< std::string > *rclasses=nullptr)
	Get template object from cache by object's ID.
template<class T >
T *	find (const std::string &id)
	Find template object using ID.
template<class T >
bool	is_valid (const T *object) noexcept
	Checks validity of pointer to an objects of given user class.
template<class T >
void	update (const std::vector< std::string > &modified, const std::vector< std::string > &removed, const std::vector< std::string > &created)
	Update cache of objects in case of modification.
void	update (const std::string &class_name, const std::vector< std::string > &modified, const std::vector< std::string > &removed, const std::vector< std::string > &created)
void	unread_all ()
	Set the status of all objects in cache to unread.
template<class T >
const T *	_ref (ConfigObject &obj, const std::string &name, bool read_children)
	Get signle value of object's relation and instantiate result with it (multi-thread safe).
template<class T >
void	_ref (ConfigObject &obj, const std::string &name, std::vector< const T * > &results, bool read_children)
	Get multiple values of object's relation and instantiate result with them (multi-thread safe).
template<class T >
void	_reset_objects ()
	Update state of objects after abort operations.
void	_rename_object (std::string class_name, std::string old_id, std::string new_id)
	Rename object of given template class (multi-thread unsafe).
void	update_class_maps ()
	Update the internal class domains map.

Private Member Functions
void	update_class_domain_map ()

Private Attributes
Configuration &	m_confdb
std::mutex	m_mutex
conffwk::fmap< uint >	m_class_domain_map
std::unordered_map< uint, DalDomain >	m_cache_domains

Friends
class	DalObject

Detailed Description

DalRegistry: A registry of DalObjects It provides a single interface to create, cache and manage DalObjecs.

Definition at line 19 of file DalRegistry.hpp.

Constructor & Destructor Documentation

DalRegistry()

dunedaq::conffwk::DalRegistry::DalRegistry

(

conffwk::Configuration &

confdb

)

Construct a new Dal Registry object.

Parameters

confdb

Reference to a Configuration object;

Definition at line 8 of file DalRegistry.cpp.

                                                       : 
  m_confdb(confdb) {
}

~DalRegistry()

dunedaq::conffwk::DalRegistry::~DalRegistry

(

)

Definition at line 13 of file DalRegistry.cpp.

                          {
}

Member Function Documentation

_ref() [1/2]

template<class T >

const T * dunedaq::conffwk::DalRegistry::_ref	(	ConfigObject &	obj,
		const std::string &	name,
		bool	read_children )

Get signle value of object's relation and instantiate result with it (multi-thread safe).

The method is used by the code generated by the genconffwk utility.

Parameters

obj	object
name	name of the relationship
init	if true, the object and it's referenced objects are initialized

Returns

Return non-null pointer to object of user class in case if relationship with such name exists and it's value is set. Otherwise the method returns 0.

Exceptions

dunedaq::conffwk::Generic

in case of a problem (e.g. no relationship with such name, plug-in specific problem)

Definition at line 164 of file DalRegistry.hxx.

{
  ConfigObject res;
 
  try {
    obj.get(name, res);
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, Configuration::mk_ref_ex_text("an object", T::s_class_name, name, obj).c_str(), ex));
  }
 
  return ((!res.is_null()) ? this->get<T>(res, read_children, read_children) : nullptr);
}

_ref() [2/2]

template<class T >

void dunedaq::conffwk::DalRegistry::_ref	(	ConfigObject &	obj,
		const std::string &	name,
		std::vector< const T * > &	results,
		bool	read_children )

Get multiple values of object's relation and instantiate result with them (multi-thread safe).

The method is used by the code generated by the genconffwk utility.

Parameters

obj	object
name	name of the relationship
objects	returned value
init	if true, the objects and their referenced objects are initialized

Exceptions

dunedaq::conffwk::Generic

in case of a problem (e.g. no relationship with such name, plug-in specific problem)

Definition at line 182 of file DalRegistry.hxx.

{
 
  std::vector<ConfigObject> objs;
 
  results.clear();
 
  try {
    obj.get(name, objs);
    results.reserve(objs.size());
 
    for (auto& i : objs) {
      auto ptr = this->get<T>(i, read_children, read_children);
      results.push_back(ptr);
    }
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, Configuration::mk_ref_ex_text("objects", T::s_class_name, name, obj).c_str(), ex));
  }
}

_rename_object()

void dunedaq::conffwk::DalRegistry::_rename_object	(	std::string	class_name,
		std::string	old_id,
		std::string	new_id )

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.

Parameters

cache_ptr	pointer to the cache of template object of given template class (has to be downcasted)
old_id	old object ID
new_id	new object ID

Definition at line 198 of file DalRegistry.cpp.

                                                                                    {
  // Find the class domain of T
  auto it_dom = m_class_domain_map.find(&DalFactory::instance().get_known_class_name_ref(class_name));
 
  // Class not known, this should not happen
  if ( it_dom == m_class_domain_map.end() ) {
    throw dunedaq::conffwk::NotFound(ERS_HERE, class_name.c_str(), old_id.c_str());
  }
 
  auto& domain = m_cache_domains[it_dom->second];
 
  auto it = domain.cache.find(old_id);
  if (it == domain.cache.end())
    return;
 
  domain.cache[new_id] = it->second;
  domain.cache.erase(it);
 
  std::lock_guard<std::mutex> scoped_lock(it->second->m_mutex);
  it->second->p_UID = new_id;
  
}

_reset_objects()

template<class T >

void dunedaq::conffwk::DalRegistry::_reset_objects

(

)

Update state of objects after abort operations.

It is used by automatically generated data access libraries.

Definition at line 236 of file DalRegistry.hxx.

                            {
 
  // Find the class domain of T
  auto it_dom = m_class_domain_map.find(&DalFactory::instance().get_known_class_name_ref(T::s_class_name));
 
  // Class not known, this should not happen
  if ( it_dom == m_class_domain_map.end() ) {
    throw dunedaq::conffwk::NotFound(ERS_HERE, "class", T::s_class_name.c_str());
  }
 
  auto& domain = m_cache_domains[it_dom->second];
 
  // Loop over the objects in the domain and reset those inheriting from T
  for( const auto& [uid, ptr] : domain.cache ) {
    
 
    T* obj_ptr = dynamic_cast<T*>(ptr);
    
    if (!obj_ptr)
      continue;
 
    std::lock_guard<std::mutex> scoped_lock(domain.mutex);
    obj_ptr->p_was_read = false;
  }
}

clear()

void dunedaq::conffwk::DalRegistry::clear

(

)

Clear the content of the registy.

Definition at line 85 of file DalRegistry.cpp.

                   {
  for( const auto& [index, domain] : m_cache_domains ) {
 
    for(const auto& [uid, ptr] : domain.cache ) {
      delete ptr;
    }
  }
 
  m_class_domain_map.clear();
}

configuration() [1/2]

Configuration & dunedaq::conffwk::DalRegistry::configuration ( )

inline

Definition at line 37 of file DalRegistry.hpp.

{ return m_confdb; }

configuration() [2/2]

const Configuration & dunedaq::conffwk::DalRegistry::configuration ( ) const

inline

Definition at line 38 of file DalRegistry.hpp.

{ return m_confdb; }

find()

template<class T >

T * dunedaq::conffwk::DalRegistry::find

(

const std::string &

id

)

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 null pointer is returned.

Parameters

id	ID of generated object

Returns

Return pointer to object.

Exceptions

dunedaq::conffwk::Generic

is no such class for loaded configuration DB schema or in case of an error

Definition at line 146 of file DalRegistry.hxx.

                                      {
  std::lock_guard<std::mutex> scoped_lock(m_mutex);
 
  auto it_dom = m_class_domain_map.find(&T::s_class_name);
 
  if ( it_dom == m_class_domain_map.end()) {
    return nullptr;
  }
 
  auto& domain = m_cache_domains[it_dom.second];
  auto it_obj = domain.cache.find(id);
  return (it_obj != domain.cache.end() ? dynamic_cast<T*>(it_obj->second) : nullptr);
}

get() [1/4]

template<class T >

T * dunedaq::conffwk::DalRegistry::get	(	ConfigObject &	obj,
		bool	init_children = false,
		bool	init_object = true )

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 null pointer is returned.

Parameters

conffwk	the configuration object
obj	the conffwk object used to set for the template object
init_children	if true, the referenced objects are initialized (only applicable during creation of new object)
init_object	if true, the object's attributes and relationships are read(only applicable during creation of new object)

Returns

Return pointer to object.

Exceptions

dunedaq::conffwk::Generic

is no such class for loaded configuration DB schema or in case of an error

Definition at line 12 of file DalRegistry.hxx.

                                                                        {
 
  TLOG_DEBUG(50) << "Building object " << obj.UID() << " of class " << obj.class_name() << " and returning class " << T::s_class_name;
 
  // Ensure that T is a superclass of (or the same class as) obj.class_name()
  if ( not (
    m_confdb.is_superclass_of(obj.class_name(), T::s_class_name) ||
    m_confdb.is_superclass_of(T::s_class_name, obj.class_name())
   )) {
    // do nothing if this is the case
    return nullptr;
  }
 
  // Find the class domain of T
  auto it_dom = m_class_domain_map.find(&DalFactory::instance().get_known_class_name_ref(T::s_class_name));
  
  // Class not known, this should not happen
  if ( it_dom == m_class_domain_map.end() ) {
    const std::string id(obj.UID() + '@' + obj.class_name());
    throw dunedaq::conffwk::NotFound(ERS_HERE, "object", id.c_str());
  }
 
  auto& domain = m_cache_domains[it_dom->second];
 
  DalObject*& dal_ptr(domain.cache[obj.m_impl->m_id]);
  T* result = dynamic_cast<T*>(dal_ptr);
 
  if (result == nullptr) {
    // result = new T(*this, obj);
    dal_ptr = DalFactory::instance().make(*this, obj, T::s_class_name);
 
    TLOG_DEBUG(50) << "Casting " << obj.UID() << " of class " << obj.class_name() << " to " << T::s_class_name;
    result = dynamic_cast<T*>(dal_ptr);
    TLOG_DEBUG(50) << "From " << (void*)dal_ptr << " to " << (void*)result;
 
    if (init_object) {
      std::lock_guard<std::mutex> scoped_lock(result->m_mutex);
      result->init(init_children);
    }
 
  } 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
  
  }
 
  TLOG_DEBUG(50) << "Returning " << (void*)result;
 
  return result;
}

get() [2/4]

DalObject * dunedaq::conffwk::DalRegistry::get	(	ConfigObject &	obj,
		bool	upcast_unregistered = false )

Definition at line 98 of file DalRegistry.cpp.

                                                            {
  
  // Find the class domain of T
  auto it_dom = m_class_domain_map.find(&DalFactory::instance().get_known_class_name_ref(obj.class_name()));
  
  // Class not known, this should not happen
  if ( it_dom == m_class_domain_map.end() ) {
    throw dunedaq::conffwk::NotFound(ERS_HERE, "class", obj.class_name().c_str());
  }
 
  auto& domain = m_cache_domains[it_dom->second];
 
  DalObject*& result(domain.cache[obj.m_impl->m_id]);
  if (result == nullptr) {
 
    result = DalFactory::instance().make(*this, obj, upcast_unregistered);
 
  } 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
  
  }
 
  return result;   
}

get() [3/4]

template<class T >

T * dunedaq::conffwk::DalRegistry::get	(	const std::string &	name,
		bool	init_children = false,
		bool	init_object = true,
		unsigned long	rlevel = 0,
		const std::vector< std::string > *	rclasses = nullptr )

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 null pointer is returned.

Parameters

conffwk	the configuration object
name	object identity
init_children	if true, the referenced objects are initialized (only applicable during creation of new object)
init_object	if true, the object's attributes and relationships are read(only applicable during creation of new object)
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)
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)

Returns

Return pointer to object. It can be null, if there is no such object found.

Exceptions

dunedaq::conffwk::Generic

is no such class for loaded configuration DB schema or in case of an error

Definition at line 67 of file DalRegistry.hxx.

                                                                                                                                         {
 
  TLOG_DEBUG(50) << "Building object " << name;
 
  const std::string& ref_name = DalFactory::instance().get_known_class_name_ref(T::s_class_name);
 
  TLOG_DEBUG(50) << "Ref name is " << ref_name;
 
 
  // Find the class domain of T
  auto it_dom = m_class_domain_map.find(&ref_name);
 
  // Class not known, this should not happen
  if ( it_dom == m_class_domain_map.end() ) {
    const std::string id(name + '@' + T::s_class_name);
    throw dunedaq::conffwk::NotFound(ERS_HERE, "object", id.c_str());
  }
 
  auto& domain = m_cache_domains[it_dom->second];
 
  TLOG_DEBUG(50) << "Class domain for " << ref_name << " is " << it_dom->second;
 
  auto it_ptr = domain.cache.find(ref_name);
 
  TLOG_DEBUG(50) << "Cache found";
 
  if ( it_ptr == domain.cache.end()) {
    try {
      // Search for an ConfigObject of id 'name' of class 'T'
      conffwk::ConfigObject obj;
      m_confdb._get(T::s_class_name, name, obj, rlevel, rclasses);
 
      DalObject*& dal_ptr(domain.cache[obj.m_impl->m_id]);
 
      T* result = dynamic_cast<T*>(dal_ptr);
 
 
      if (result == nullptr) {
        // result = new T(*this, obj);
        dal_ptr = DalFactory::instance().make(*this, obj, T::s_class_name);
 
        TLOG_DEBUG(50) << "Casting " << obj.UID() << " of class " << obj.class_name() << " to " << T::s_class_name;
        result = dynamic_cast<T*>(dal_ptr);
        TLOG_DEBUG(50) << "From " << (void*)dal_ptr << " to " << (void*)result;
 
        if (init_object) {
          std::lock_guard<std::mutex> scoped_lock(result->m_mutex);
          result->init(init_children);
        }
      } 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
      }
      
      return result;
 
    } 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());
      }
 
      return nullptr;
    }
  }
 
  std::cout << "Found " << (void*)it_ptr->second << std::endl;
  return dynamic_cast<T*>(it_ptr->second);
 
}

get() [4/4]

std::vector< const DalObject * > dunedaq::conffwk::DalRegistry::get	(	std::vector< ConfigObject > &	objs,
		bool	upcast_unregistered = false )

Definition at line 127 of file DalRegistry.cpp.

{
  std::vector<const DalObject*> result;
 
  for (auto &i : objs)
    if (DalObject *o = this->get(i,upcast_unregistered))
      result.push_back(o);
 
  return result;
}

is_valid()

template<class T >

bool dunedaq::conffwk::DalRegistry::is_valid ( const T * object )

noexcept

Checks validity of pointer to an objects of given user class.

Check if the pointer to the object is a valid pointer in the cache. Dangling pointers to removed objects may appear after notification.

Returns

Return true if the pointer is valid and false otherwise.

Definition at line 205 of file DalRegistry.hxx.

                                               {
 
  std::lock_guard<std::mutex> scoped_lock(m_mutex);
 
  auto it_dom = m_class_domain_map.find(&T::s_class_name);
  if ( it_dom == m_class_domain_map.end()) {
    return false;
  }
 
  for( const auto& [uid, ptr] : m_cache_domains[it_dom->second].cache ) {
    if ( ptr == object ) {
      return true;
    }
  }
}

unread_all()

void dunedaq::conffwk::DalRegistry::unread_all

(

)

Set the status of all objects in cache to unread.

Definition at line 182 of file DalRegistry.cpp.

                        {
 
  for( const auto& [dom_id, domain] : m_cache_domains ) {
  
    std::lock_guard<std::mutex> scoped_lock(domain.mutex);
 
    for( const auto& [id, ptr] : domain.cache ) {
      ptr->p_was_read = false;
    }
 
  }
}

update() [1/2]

void dunedaq::conffwk::DalRegistry::update	(	const std::string &	class_name,
		const std::vector< std::string > &	modified,
		const std::vector< std::string > &	removed,
		const std::vector< std::string > &	created )

Definition at line 140 of file DalRegistry.cpp.

                                                 {
  
  // Find the class domain of T
  auto it_dom = m_class_domain_map.find(&DalFactory::instance().get_known_class_name_ref(class_name));
 
  // Class not known, this should not happen
  if ( it_dom == m_class_domain_map.end() ) {
    throw dunedaq::conffwk::NotFound(ERS_HERE, "class", class_name.c_str());
  }
 
  // get the correct cache domain
  auto& domain = m_cache_domains[it_dom->second];
 
  for( const auto& [uid, ptr] : domain.cache ) {
 
    // Check if the ptr class is derived from class_name
    m_confdb.is_superclass_of(ptr->class_name(), class_name);
    
    if (!ptr)
      continue;
 
    bool update = (
      ( std::find(modified.begin(), modified.end(), ptr->UID()) != modified.end() ) or
      ( std::find(removed.begin(), removed.end(), ptr->UID()) != removed.end() ) or
      ( std::find(created.begin(), created.end(), ptr->UID()) != created.end() )
    );
 
    if (!update)
      continue;
 
    std::lock_guard<std::mutex> scoped_lock(domain.mutex);
    ptr->p_was_read = false;
  }
}

update() [2/2]

template<class T >

void dunedaq::conffwk::DalRegistry::update	(	const std::vector< std::string > &	modified,
		const std::vector< std::string > &	removed,
		const std::vector< std::string > &	created )

Update cache of objects in case of modification.

Only is called, when a user subscription to related class is set. It is used by automatically generated data access libraries.

Parameters

modified	vector of modified objects of given user class (objects to be re-read in cache)
removed	vector of removed objects of given user class (objects to be removed from cache)
created	vector of created objects of given user class (objects to be reset in cache, if they were removed)

Definition at line 225 of file DalRegistry.hxx.

                                                 {
  
  this->update(T::s_class_name, modified, removed, created);
}

update_class_domain_map()

void dunedaq::conffwk::DalRegistry::update_class_domain_map ( )

private

Definition at line 68 of file DalRegistry.cpp.

                                     {
 
  m_class_domain_map.clear();
 
  auto domains = m_confdb.find_class_domains();
  // TODO: keep a local copy of the domains
  for (size_t i(0); i < domains.size(); ++i) {
    const auto& dom = domains[i];
    for (const auto& class_name : dom) {
      m_class_domain_map[&conffwk::DalFactory::instance().get_known_class_name_ref(class_name)] = i;
      TLOG_DEBUG(9) << " - " << class_name << " : " <<  i;
    }
  }
}

update_class_maps()

void dunedaq::conffwk::DalRegistry::update_class_maps ( )

inline

Update the internal class domains map.

Definition at line 211 of file DalRegistry.hpp.

                           {
    this->update_class_domain_map();
  }

Friends And Related Symbol Documentation

DalObject

friend class DalObject

friend

Definition at line 21 of file DalRegistry.hpp.

Member Data Documentation

m_cache_domains

std::unordered_map<uint,DalDomain> dunedaq::conffwk::DalRegistry::m_cache_domains

private

Definition at line 226 of file DalRegistry.hpp.

m_class_domain_map

conffwk::fmap<uint> dunedaq::conffwk::DalRegistry::m_class_domain_map

private

Definition at line 224 of file DalRegistry.hpp.

m_confdb

Configuration& dunedaq::conffwk::DalRegistry::m_confdb

private

Definition at line 218 of file DalRegistry.hpp.

m_mutex

std::mutex dunedaq::conffwk::DalRegistry::m_mutex

mutableprivate

Definition at line 220 of file DalRegistry.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/conffwk/include/conffwk/DalRegistry.hpp
• /github/workspace/dunedaq/sourcecode/conffwk/include/conffwk/details/DalRegistry.hxx
• /github/workspace/dunedaq/sourcecode/conffwk/src/DalRegistry.cpp