dunedaq::conffwk::Configuration Class Reference

Defines base class for cache of template objects. More...

#include <Configuration.hpp>

Collaboration diagram for dunedaq::conffwk::Configuration:

Classes
struct	CallbackSubscription
struct	CallbackPreSubscription
class	AttributeConverterBase
class	AttributeConverter
	Virtual converter class. More...

Public Types
typedef void(*)	notify(const std::vector< ConfigurationChange * > &changed_classes, void *parameter)
	The user notification callback function which is invoked in case of changes.
typedef void(*)	pre_notify(void *parameter)
	The user notification callback function which is invoked before changes are going to be applied.
typedef CallbackSubscription *	CallbackId
	Callback identifier.

Public Member Functions
	Configuration (const std::string &spec)
	Constructor to build a configuration object using implementation plug-in.
	Configuration ()
const std::string &	get_impl_spec () const noexcept
const std::string &	get_impl_name () const noexcept
const std::string &	get_impl_param () const noexcept
	~Configuration () noexcept
	Destructor to destroy a configuration object.
CallbackId	subscribe (const ConfigurationSubscriptionCriteria &criteria, notify user_cb, void *user_param=nullptr)
	Subscribe on configuration changes.
CallbackId	subscribe (pre_notify user_cb, void *user_param=nullptr)
	Subscribe on pre-notification on configuration changes.
void	unsubscribe (CallbackId cb_handler=0)
	Remove callback function.
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) noexcept
	Update cache of objects in case of modification.
void	update_cache (std::vector< ConfigurationChange * > &changes) noexcept
	System function invoked in case of modifications.
template<class T>
void	_reset_objects () noexcept
	Update state of objects after abort operations.
void	unread_all_objects (bool unread_implementation_objs=false) noexcept
	Unread all template (i.e. set their state as uninitialized) and implementation objects (i.e. clear their cache).
void	unread_template_objects () noexcept
	Unread all template (i.e. set their state as uninitialized) objects.
void	unread_implementation_objects (dunedaq::conffwk::ObjectState state) noexcept
	Unread implementation objects (i.e. clear their cache).
void	create (const std::string &at, const std::string &class_name, const std::string &id, ConfigObject &object)
	Create new object by class name and object id.
void	create (const ConfigObject &at, const std::string &class_name, const std::string &id, ConfigObject &object)
	Create new object by class name and object id.
template<class T>
const T *	create (const std::string &at, const std::string &id, bool init_object=false)
	Create object of given class by identity and instantiate the template parameter with it.
template<class T>
const T *	create (const DalObject &at, const std::string &id, bool init_object=false)
	Create object of given class by identity and instantiate the template parameter with it.
void	destroy_obj (ConfigObject &object)
	Destroy object.
template<class T>
void	destroy (T &obj)
	Destroy object of given class.
bool	test_object (const std::string &class_name, const std::string &id, unsigned long rlevel=0, const std::vector< std::string > *rclasses=0)
	Test the object existence.
void	get (const std::string &class_name, const std::string &id, ConfigObject &object, unsigned long rlevel=0, const std::vector< std::string > *rclasses=0)
	Get object by class name and object id (multi-thread safe).
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)
	Get all objects of class.
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)
	Get path between objects.
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)
	Get object of given class by identity and instantiate the template parameter with it (multi-thread safe).
template<class T>
const T *	get (ConfigObject &obj, bool init_children=false, bool init=true)
	Get object of given class by object reference and instantiate the template parameter with it (multi-thread safe).
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)
	Get all objects of given class and instantiate a vector of the template parameters object with it (multi-thread safe).
template<class T>
const T *	get (ConfigObject &obj, const std::string &id)
	Generate object of given class by object reference and instantiate the template parameter with it (multi-thread safe).
template<class T>
const T *	find (const std::string &id)
	Find object of given class (multi-thread safe).
template<class T>
const T *	ref (ConfigObject &obj, const std::string &name, bool init=false)
	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 * > &objects, bool init=false)
	Get multiple values of object's relation and instantiate result with them (multi-thread safe).
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)
	Get template DAL objects holding references on this object via given relationship (multi-thread safe).
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)
	Get DAL objects holding references on this object via given relationship (multi-thread safe).
template<class TARGET, class SOURCE>
const TARGET *	cast (const SOURCE *s) noexcept
	Cast objects from one class to another (multi-thread safe).
template<class T>
void	downcast_dal_objects (const std::vector< const T * > &objs, bool, std::vector< const DalObject * > &result)
template<class T>
void	downcast_dal_object (const T *obj, bool, std::vector< const DalObject * > &result)
template<class T>
const T *	_find (const std::string &id)
	Multi-thread unsafe version of find(const std::string&) method.
template<class T>
const T *	_ref (ConfigObject &obj, const std::string &name, bool read_children)
	Multi-thread unsafe version of ref(ConfigObject&, const std::string&, bool); The method should not be used by user.
template<class T>
void	_ref (ConfigObject &obj, const std::string &name, std::vector< const T * > &results, bool read_children)
	Multi-thread unsafe version of ref(ConfigObject&, const std::string&, std::vector<const T*>&, bool); The method should not be used by user.
bool	try_cast (const std::string &target, const std::string &source) noexcept
	Checks if cast from source class to target class is allowed.
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
bool	loaded () const noexcept
	Check if database is correctly loaded.
void	load (const std::string &db_name)
	Load database according to the name. If name is empty, take it from TDAQ_DB_NAME and TDAQ_DB_DATA environment variables.
void	unload ()
	Unload database.
void	create (const std::string &db_name, const std::list< std::string > &includes)
	Create database.
bool	is_writable (const std::string &db_name) const
	Get write access status.
void	add_include (const std::string &db_name, const std::string &include)
	Add include file to existing database.
void	remove_include (const std::string &db_name, const std::string &include)
	Remove include file.
void	get_includes (const std::string &db_name, std::list< std::string > &includes) const
	Get include files.
void	get_updated_dbs (std::list< std::string > &dbs) const
	Get list of updated files to be committed.
void	set_commit_credentials (const std::string &user, const std::string &password)
	Set commit credentials.
void	commit (const std::string &log_message="")
	Commit database changes.
void	abort ()
	Abort database changes.
void	prefetch_all_data ()
	Prefetch all data into client cache.
std::vector< dunedaq::conffwk::Version >	get_changes ()
	Get new conffwk versions.
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)
	Get repository versions in interval.
const dunedaq::conffwk::class_t &	get_class_info (const std::string &class_name, bool direct_only=false)
	The method provides access to description of class.
void	export_schema (boost::property_tree::ptree &tree, const std::string &classes="", bool direct_only=false)
	Export configuration schema into ptree.
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="")
	Export configuration data into ptree.
template<class T>
void	register_converter (AttributeConverter< T > *object) noexcept
	Register user function for attribute conversion.
template<class T>
void	convert (T &value, const ConfigObject &obj, const std::string &attr_name) noexcept
	Converts single value.
template<class T>
void	convert2 (std::vector< T > &value, const ConfigObject &obj, const std::string &attr_name) noexcept
	Converts vector of single values.
void	print_profiling_info () noexcept
	Print out profiling information.
const conffwk::fmap< conffwk::fset > &	superclasses () const noexcept
const conffwk::fmap< conffwk::fset > &	subclasses () const
std::vector< std::string >	classes_in_python () const
void	print (std::ostream &) const noexcept
	Prints out details of configuration object.
void	add_action (ConfigAction *ac)
void	remove_action (ConfigAction *ac)
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)
const std::string &	get_schema_path_pybind (const std::string &class_name)

Static Public Member Functions
static void	system_cb (std::vector< ConfigurationChange * > &, Configuration *) noexcept
	System callback function invoked in case of modifications.
static void	system_pre_cb (Configuration *) noexcept
	System callback function invoked in case of pre-modifications.

Private Types
typedef std::set< CallbackSubscription *, std::less< CallbackSubscription * > >	CallbackSet
typedef std::set< CallbackPreSubscription *, std::less< CallbackPreSubscription * > >	PreCallbackSet

Private Member Functions
void	reset_subscription ()
void	_unread_template_objects () noexcept
void	_unread_implementation_objects (dunedaq::conffwk::ObjectState state) noexcept
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)
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)
const dunedaq::conffwk::class_t &	_get_class_info (const std::string &class_name, bool direct_only=false)
void	set_subclasses () noexcept
void	set_class_domain_map ()
void	update_classes () noexcept
std::deque< std::set< std::string > >	find_class_domains ()
void	rename_object (ConfigObject &obj, const std::string &new_id)
	Cache of template object of given type.
CallbackSubscription *	find_callback (CallbackId cb_handler) const
void	action_on_update (const ConfigObject &obj, const std::string &name)
	Configuration (const Configuration &)
Configuration &	operator= (const Configuration &)

Static Private Member Functions
static void	update_impl_objects (conffwk::pmap< conffwk::map< ConfigObjectImpl * > * > &cache, ConfigurationChange &change, const std::string *class_name)
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

Private Attributes
conffwk::map< dunedaq::conffwk::class_t * >	p_direct_classes_desc_cache
conffwk::map< dunedaq::conffwk::class_t * >	p_all_classes_desc_cache
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
conffwk::fmap< conffwk::fset >	p_superclasses
conffwk::fmap< conffwk::fset >	p_subclasses
conffwk::fmap< uint >	p_class_domain_map
conffwk::map< std::list< AttributeConverterBase * > * >	m_convert_map
ConfigurationImpl *	m_impl
std::string	m_impl_spec
std::string	m_impl_name
std::string	m_impl_param
void *	m_shlib_h
CallbackSet	m_callbacks
PreCallbackSet	m_pre_callbacks
std::list< ConfigAction * >	m_actions
DalRegistry	m_registry
std::mutex	m_impl_mutex
std::mutex	m_tmpl_mutex
std::mutex	m_actn_mutex
std::mutex	m_else_mutex

Friends
class	DalObject
class	ConfigObject
class	ConfigurationImpl
class	DalRegistry

Detailed Description

Defines base class for cache of template objects.

The class is used as a base class for any cached template object. It defines:

• virtual destructor
• DAL factory functions

Provides abstract interface to database data.

The class provides interfaces to data access and notification on data changes which are independent from the database implementation.

The class is an entry point to the database information. It provides access to the database objects by name of the class and optionally (for named objects) by object identities. Normally, user should use this class to open/close database and to access objects via template get methods invoked with classes generated by the genconffwk utility.

Below there is brief description of main methods. Most of then can only be used after successful initialization (i.e. database load) of the Configuration object.

Methods throw exceptions in case of an error unless noexcept is explicitly used in their specification. The following exceptions can be thrown:

• dunedaq::conffwk::Generic is used to report most of the problems (bad DB, wrong parameter, plug-in specific, etc.)
• dunedaq::conffwk::NotFound the conffwk object accessed by ID is not found, class accessed by name is not found
• dunedaq::conffwk::DeletedObject accessing template object that has been deleted (via notification or by the user's code)

  All above exceptions have common class dunedaq::conffwk::Exception, that can be used to catch all of them.
  

try {
  // load database using oks file /tmp/mydb.data.xml
Configuration db("oksconflibs:/tmp/mydb.data.xml");
 
  // get object "foo@bar"
ConfigObject obj;
db.get("bar", "foo", obj);
 
  // print object to the standard output stream
obj.print_ref(std::cout, db);
}
// the catch of dunedaq::conffwk::NotFound exception is optional:
// it is only used to distinguish NotFound exception from other possible once
catch (dunedaq::conffwk::NotFound & ex) {
std::cerr << "Object foo@bar is not found: " << ex << std::endl;
}
// always catch this exception: it can come unexpectedly from DBMS implementation,
// e.g. because of hardware problems or lack of computer resources
catch (dunedaq::conffwk::Exception & ex) {
std::cerr << "ERROR: " << ex << std::endl;
}

Database Manipulation

To get data a database can be opened, closed and it's state can be checked by the following methods:

• load() open database (by default, the database is opened by the constructor)
• unload() closes database (by default, the database is closed by the destructor)
• loaded() returns true, if a database is correctly loaded

To create or to modify data a database the following methods can be used:

• create(const std::string&, const std::string&, const std::list<std::string>&) create new database
• add_include() add include to an existing database
• remove_include() remove include from an existing database
• commit() save chain of changes
• abort() cancel all previous changes

Objects Access

The access to the objects is provided via two main methods:

• get(const std::string& class, const std::string& id, ConfigObject&, unsigned long, const std::vector<std::string> ) get single object by name of class and id
• get(const std::string& class, std::vector<ConfigObject>&, const std::string& query, unsigned long, const std::vector<std::string> *) get objects of class by name

  Below there is example to read all computer objects
  

  try {
  Configuration db("oksconflibs:daq/partitions/part_hlt.data.xml");
   
  // read all objects of "Computer" class
  std::vector<ConfigObject> hosts;
  db.get("Computer", hosts);
   
  // print details of the Computer objects
  for (const auto& x : objects)
    x.print_ref(std::cout, db);
  }
  catch (dunedaq::conffwk::Exception & ex) {
  std::cerr << "ERROR: " << ex << std::endl;
  }

  For objects of classes generated by genconffwk there are analogous template methods which
  in addition store pointers to objects in the cache and which to be used by end-user:
  - get(const std::string& id, bool, bool, unsigned long, const std::vector<std::string> *) return const pointer to
  

  object of given user class
• get(std::vector<const T*>& objects, bool, bool, const std::string& query, unsigned long, const std::vector<std::string> *) fills vector of objects of given user class

  Below there is an example for generated \b dal package:
  

  // include generated files for classes used below
  #include "dal/Variable.h"
  #include "dal/Segment.h"
   
  try {
  Configuration db("oksconflibs:daq/partitions/part_hlt.data.xml");
   
  // read all variables with Name = "TDAQ_DB_NAME"
  std::vector<const daq::core::Variable*> vars;
  db.get(vars, false, true, "(all (\"Name\" \"TDAQ_ERS_INFO\" =))");
   
  // print variables
  std::cout << "Got " << vars.size() << " variables with name TDAQ_ERS_INFO:\n";
  for (const auto& x : vars)
    std::cout << "object " << x << " => " << x->get_Value() << std::endl;
   
  // get segment with id = "online" and print if found
  if (const daq::core::Segment * p = db.get<daq::core::Segment>("online"))
    std::cout << "The segment object is: " << *p << std::endl;
  }
  catch (dunedaq::conffwk::Exception & ex) {
  std::cerr << "ERROR: " << ex << std::endl;
  }

  \par Notification
  
  To subscribe and unsubscribe on changes it is necessary to create a subscription criteria
  (see ConfigurationSubscriptionCriteria class for more information).
  When a subscription criteria object is created, the following methods can be used:
  - subscribe() subscribe on any changes according criteria
  - unsubscribe() unsubscribe above changes (the CallbackId is returned by above method)
  

Definition at line 233 of file Configuration.hpp.

Member Typedef Documentation

CallbackId

typedef CallbackSubscription* dunedaq::conffwk::Configuration::CallbackId

Callback identifier.

It uniquely identifies a callback inside given process. It is returned by subscribe() method and must be used as parameter for the unsubscribe() methods.

Definition at line 328 of file Configuration.hpp.

CallbackSet

typedef std::set<CallbackSubscription*, std::less<CallbackSubscription*> > dunedaq::conffwk::Configuration::CallbackSet

private

Definition at line 1679 of file Configuration.hpp.

notify

typedef void(*) dunedaq::conffwk::Configuration::notify(const std::vector< ConfigurationChange * > &changed_classes, void *parameter)

The user notification callback function which is invoked in case of changes.

Parameters

changed_classes	vector of changed classes
parameter	user-defined parameter

Definition at line 292 of file Configuration.hpp.

pre_notify

typedef void(*) dunedaq::conffwk::Configuration::pre_notify(void *parameter)

The user notification callback function which is invoked before changes are going to be applied.

Parameters

parameter

user-defined parameter

Definition at line 301 of file Configuration.hpp.

PreCallbackSet

typedef std::set<CallbackPreSubscription*, std::less<CallbackPreSubscription*> > dunedaq::conffwk::Configuration::PreCallbackSet

private

Definition at line 1680 of file Configuration.hpp.

Constructor & Destructor Documentation

Configuration() [1/3]

dunedaq::Configuration::Configuration

(

const std::string &

spec

)

Constructor to build a configuration object using implementation plug-in.

The constructor expects parameter in format "plugin-name:plugin-parameter". The plugin-name is used to get implementation shared library by adding "lib" prefix and ".so" suffix, e.g. "oksconflibs" -> "liboksconflibs.so". The plugin-parameter is optional; if non-empty, it is passed to the plug-in constructor.

Parameters

spec	database name to be understood by the database implementation

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 102 of file Configuration.cpp.

  : p_number_of_cache_hits(0)
  , p_number_of_template_object_created(0)
  , p_number_of_template_object_read(0)
  , m_impl(nullptr)
  , m_shlib_h(nullptr)
  , m_registry(*this)
{
  std::string s;
 
  if (spec.empty()) {
    if (const char* env = getenv("TDAQ_DB"))
      m_impl_spec = env;
  } else {
    m_impl_spec = spec;
  }
 
  if (m_impl_spec.empty())
    throw dunedaq::conffwk::Generic(
      ERS_HERE,
      "no database parameter found (check parameter of the constructor or value of TDAQ_DB environment variable)");
 
  std::string::size_type idx = m_impl_spec.find_first_of(':');
 
  if (idx == std::string::npos) {
    m_impl_name = m_impl_spec;
  } else {
    m_impl_name = m_impl_spec.substr(0, idx);
    m_impl_param = m_impl_spec.substr(idx + 1);
  }
 
  std::string plugin_name = std::string("lib") + m_impl_name + ".so";
  std::string impl_creator = std::string("_") + m_impl_name + "_creator_";
 
  // load plug-in
  m_shlib_h = dlopen(plugin_name.c_str(), RTLD_LAZY | RTLD_GLOBAL);
 
  if (!m_shlib_h) {
    std::ostringstream text;
    text << "failed to load implementation plug-in \'" << plugin_name << "\': \"" << dlerror() << '\"';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str()));
  }
 
  // search in plug-in implementation creator function
 
  ConfigurationImpl* (*f)(const std::string& spec);
 
  f = (ConfigurationImpl * (*)(const std::string&)) dlsym(m_shlib_h, impl_creator.c_str());
 
  char* error = 0;
 
  if ((error = dlerror()) != 0) {
    std::ostringstream text;
    text << "failed to find implementation creator function \'" << impl_creator << "\' in plug-in \'" << plugin_name
         << "\': \"" << error << '\"';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str()));
  }
 
  // create implementation
 
  m_impl = (*f)(m_impl_param);
 
  if (m_impl) {
    // m_impl->get_superclasses(p_superclasses);
    // set_subclasses();
    update_classes();
    m_impl->set(this);
  }
 
  if (check_prefetch_needs())
    m_impl->prefetch_all_data();
 
  TLOG_DEBUG(2) << "\n*** DUMP CONFIGURATION ***\n" << *this;
}

Configuration() [2/3]

dunedaq::conffwk::Configuration::Configuration

(

)

~Configuration()

dunedaq::Configuration::~Configuration ( )

noexcept

Destructor to destroy a configuration object.

The destructor unloads database for given database implementation and destroys all user objects in cache.

Definition at line 213 of file Configuration.cpp.

{
  if (::getenv("TDAQ_DUMP_CONFFWK_PROFILER_INFO"))
    print_profiling_info();
 
  try {
    unload();
 
    if (m_shlib_h) {
      std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
      delete m_impl;
      m_impl = 0;
      // dlclose(m_shlib_h);
      m_shlib_h = 0;
    }
  } catch (dunedaq::conffwk::Generic& ex) {
    ers::error(ex);
  }
}

Configuration() [3/3]

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

private

Member Function Documentation

_find()

template<class T>

const T * dunedaq::conffwk::Configuration::_find

(

const std::string &

id

)

Multi-thread unsafe version of find(const std::string&) method.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 57 of file Configuration.hxx.

{
  // 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() [1/4]

template<class T>

const T * dunedaq::conffwk::Configuration::_get ( ConfigObject & obj, bool init_children = false, bool init = true )

private

Exceptions

dunedaq::conffwk::Generic

Definition at line 42 of file Configuration.hxx.

{
  return m_registry.get<T>(obj, init_children, init_object);
}

_get() [2/4]

void dunedaq::conffwk::Configuration::_get ( const std::string & class_name, const std::string & id, ConfigObject & object, unsigned long rlevel, const std::vector< std::string > * rclasses )

private

Exceptions

dunedaq::conffwk::Generic

or dunedaq::conffwk::NotFound

_get() [3/4]

template<class T>

const T * dunedaq::conffwk::Configuration::_get ( const std::string & id, bool init_children = false, bool init = true, unsigned long rlevel = 0, const std::vector< std::string > * rclasses = 0 )

private

Exceptions

dunedaq::conffwk::Generic

Definition at line 30 of file Configuration.hxx.

{
  return m_registry.get<T>(name, init_children, init_object, rlevel, rclasses);
}

_get() [4/4]

template<class T>

void dunedaq::conffwk::Configuration::_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 )

private

Exceptions

dunedaq::conffwk::Generic

Definition at line 67 of file Configuration.hxx.

{
  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_class_info()

const dunedaq::conffwk::class_t & dunedaq::Configuration::_get_class_info ( const std::string & class_name, bool direct_only = false )

private

Definition at line 832 of file Configuration.cpp.

{
  conffwk::map<dunedaq::conffwk::class_t*>& d_cache(direct_only ? p_direct_classes_desc_cache
                                                                : p_all_classes_desc_cache);
 
  conffwk::map<dunedaq::conffwk::class_t*>::const_iterator i = d_cache.find(class_name);
 
  if (i != d_cache.end())
    return *(i->second);
 
  try {
    dunedaq::conffwk::class_t* d = m_impl->get(class_name, direct_only);
    d_cache[class_name] = d;
    return *d;
  }
  // catch Generic exception only; the NotFound is forwarded from implementation
  catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to get description of class \'" << class_name << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

_make_instance()

template<class T>

DalObject * dunedaq::conffwk::Configuration::_make_instance ( ConfigObject & obj, const std::string & uid )

inlineprivate

Exceptions

dunedaq::conffwk::Generic

Definition at line 1009 of file Configuration.hpp.

  {
    // note upcast since the _get() returns pointer to T
    return const_cast<T*>(_get<T>(obj, uid));
  }

_ref() [1/2]

template<class T>

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

Multi-thread unsafe version of ref(ConfigObject&, const std::string&, bool); The method should not be used by user.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 94 of file Configuration.hxx.

{
  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);
}

_ref() [2/2]

template<class T>

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

Multi-thread unsafe version of ref(ConfigObject&, const std::string&, std::vector<const T*>&, bool); The method should not be used by user.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 116 of file Configuration.hxx.

{
 
  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 )
  //     );
  //   }
}

_reset_objects()

template<class T>

void dunedaq::conffwk::Configuration::_reset_objects ( )

noexcept

Update state of objects after abort operations.

It is used by automatically generated data access libraries.

Definition at line 320 of file Configuration.hxx.

{
  // 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>();
}

_unread_implementation_objects()

void dunedaq::Configuration::_unread_implementation_objects ( dunedaq::conffwk::ObjectState state )

privatenoexcept

Definition at line 611 of file Configuration.cpp.

{
  for (auto& i : m_impl->m_impl_objects)
    for (auto& j : *i.second) {
      std::lock_guard<std::mutex> scoped_lock(j.second->m_mutex);
      j.second->clear();
      j.second->m_state = state;
    }
 
  for (auto& x : m_impl->m_tangled_objects) {
    std::lock_guard<std::mutex> scoped_lock(x->m_mutex);
    x->clear();
    x->m_state = state;
  }
}

_unread_template_objects()

void dunedaq::Configuration::_unread_template_objects ( )

privatenoexcept

Definition at line 605 of file Configuration.cpp.

{
  m_registry.unread_all();
}

abort()

void dunedaq::Configuration::abort

(

)

Abort database changes.

The method rolls back non-committed database modifications.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 558 of file Configuration.cpp.

{
  TLOG_DEBUG(1) << "call abort";
 
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock1(m_tmpl_mutex); // always lock template objects mutex first
  std::lock_guard<std::mutex> scoped_lock2(m_impl_mutex);
 
  try {
    m_impl->abort();
    _unread_implementation_objects(dunedaq::conffwk::Unknown);
    _unread_template_objects();
    // m_impl->get_superclasses(p_superclasses);
    // set_subclasses();
    update_classes();
 
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, "abort failed", ex));
  }
}

action_on_update()

void dunedaq::Configuration::action_on_update ( const ConfigObject & obj, const std::string & name )

private

Definition at line 75 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_actn_mutex);
  for (auto& i : m_actions)
    i->update(obj, name);
}

add_action()

void dunedaq::Configuration::add_action

(

ConfigAction *

ac

)

Add global action performed by user code on db [un]load and updates.

Definition at line 61 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_actn_mutex);
  m_actions.push_back(ac);
}

add_include()

void dunedaq::Configuration::add_include	(	const std::string &	db_name,
		const std::string &	include )

Add include file to existing database.

The method adds (and loads) existing include file to the database.

Parameters

db_name	name of database file to be included
include	file to be included

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 452 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  try {
    m_impl->add_include(db_name, include);
    // m_impl->get_superclasses(p_superclasses);
    // set_subclasses();
    update_classes();
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to add include \'" << include << "\' to database \'" << db_name << '\'';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex));
  }
}

attributes_pybind()

std::unordered_map< std::string, std::unordered_map< std::string, std::string > > dunedaq::Configuration::attributes_pybind	(	const std::string &	class_name,
		bool	all )

Definition at line 1849 of file Configuration.cpp.

{
 
  std::unordered_map<std::string, std::unordered_map<std::string, std::string>> all_attributes_properties;
 
  const dunedaq::conffwk::class_t& c = this->get_class_info(class_name, !all);
 
  for (const auto& ap : c.p_attributes) {
    std::unordered_map<std::string, std::string> attribute_properties;
    attribute_properties["type"] = dunedaq::conffwk::attribute_t::type(ap.p_type);
 
    attribute_properties["range"] = ap.p_range.empty() ? "None" : ap.p_range;
 
    attribute_properties["description"] = ap.p_description;
 
    attribute_properties["multivalue"] = ap.p_is_multi_value ? "True" : "False";
 
    attribute_properties["not-null"] = ap.p_is_not_null ? "True" : "False";
 
    attribute_properties["init-value"] = ap.p_default_value.empty() ? "None" : ap.p_default_value;
 
    all_attributes_properties[ap.p_name] = attribute_properties;
  }
 
  return all_attributes_properties;
}

cast()

template<class TARGET, class SOURCE>

const TARGET * dunedaq::conffwk::Configuration::cast ( const SOURCE * s )

inlinenoexcept

Cast objects from one class to another (multi-thread safe).

Try to cast object SOURCE to TARGET. Returns 0 if not successful. Do not use the normal dynamic_cast<T>() for database classes.

Returns

Return nullptr if the cast is not successful.

Definition at line 970 of file Configuration.hpp.

  {
    return s->template cast<TARGET>();
  }

classes_in_python()

std::vector< std::string > dunedaq::conffwk::Configuration::classes_in_python

(

)

const

commit()

void dunedaq::Configuration::commit

(

const std::string &

log_message = ""

)

Commit database changes.

The method commits the changes after a database was modified.

Parameters

log_message

log information

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 540 of file Configuration.cpp.

{
  TLOG_DEBUG(1) << "call commit";
 
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock1(m_tmpl_mutex); // always lock template objects mutex first
  std::lock_guard<std::mutex> scoped_lock2(m_impl_mutex);
 
  try {
    m_impl->commit(log_message);
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, "commit failed", ex));
  }
}

convert()

template<class T>

void dunedaq::conffwk::Configuration::convert ( T & value, const ConfigObject & obj, const std::string & attr_name )

noexcept

Converts single value.

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

Definition at line 387 of file Configuration.hxx.

{
  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);
    }
  }
}

convert2()

template<class T>

void dunedaq::conffwk::Configuration::convert2 ( std::vector< T > & value, const ConfigObject & obj, const std::string & attr_name )

noexcept

Converts vector of single values.

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

Definition at line 399 of file Configuration.hxx.

{
  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);
      }
    }
  }
}

create() [1/5]

void dunedaq::Configuration::create	(	const ConfigObject &	at,
		const std::string &	class_name,
		const std::string &	id,
		ConfigObject &	object )

Create new object by class name and object id.

The method tries to create an object with given id in given class. If found, the method fills 'object' reference.

Parameters

at	create new object at the same database file where 'at' object is located
class_name	name of the class
id	object identity
object	returned value in case of success

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 752 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    m_impl->create(at, class_name, id, object);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to create object \'" << id << '@' << class_name << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

create() [2/5]

template<class T>

const T * dunedaq::conffwk::Configuration::create	(	const DalObject &	at,
		const std::string &	id,
		bool	init_object = false )

Create object of given class by identity and instantiate the template parameter with it.

Such method to be used for user classes generated by the genconffwk utility.

Parameters

at	an existing object of class generated by genconffwk to define location of the file where to store new object
id	object identity
init_object	if true, initialize object's attributes and relationships

Returns

non-null pointer to created object.

Exceptions

dunedaq::conffwk::Generic

in case of an error

create() [3/5]

void dunedaq::Configuration::create	(	const std::string &	at,
		const std::string &	class_name,
		const std::string &	id,
		ConfigObject &	object )

Create new object by class name and object id.

The method tries to create an object with given id in given class. If found, the method fills 'object' reference.

Parameters

at	database file where to create new object
class_name	name of the class
id	object identity
object	returned value in case of success

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 739 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    m_impl->create(at, class_name, id, object);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to create object \'" << id << '@' << class_name << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

create() [4/5]

template<class T>

const T * dunedaq::conffwk::Configuration::create	(	const std::string &	at,
		const std::string &	id,
		bool	init_object = false )

Create object of given class by identity and instantiate the template parameter with it.

Such method to be used for user classes generated by the genconffwk utility.

Parameters

at	database file where to create new object
id	object identity
init_object	if true, initialise object's attributes and relationships

Returns

non-null pointer to created object.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 11 of file Configuration.hxx.

{
  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);
}

create() [5/5]

void dunedaq::Configuration::create	(	const std::string &	db_name,
		const std::list< std::string > &	includes )

Create database.

The method creates database according to the name and list of others database files to be included.

Parameters

db_name	name of new database file (must be an absolute path to non-existing file)
includes	optional list of others database files to be included

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 417 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  try {
    m_impl->create(db_name, includes);
    update_classes();
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to create database \'" << db_name << '\'';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex));
  }
}

create_and_return_obj_pybind() [1/2]

ConfigObject * dunedaq::Configuration::create_and_return_obj_pybind	(	const ConfigObject &	at,
		const std::string &	class_name,
		const std::string &	id )

Definition at line 1896 of file Configuration.cpp.

{
  auto co = new ConfigObject;
  this->create(at, class_name, id, *co);
  return co;
}

create_and_return_obj_pybind() [2/2]

ConfigObject * dunedaq::Configuration::create_and_return_obj_pybind	(	const std::string &	at,
		const std::string &	class_name,
		const std::string &	id )

Definition at line 1888 of file Configuration.cpp.

{
  auto co = new ConfigObject;
  this->create(at, class_name, id, *co);
  return co;
}

destroy()

template<class T>

void dunedaq::conffwk::Configuration::destroy

(

T &

obj

)

Destroy object of given class.

The method tries to destoy given object.

Parameters

obj	the object's reference

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 22 of file Configuration.hxx.

{
  destroy_obj(const_cast<ConfigObject&>(obj.config_object()));
}

destroy_obj()

void dunedaq::Configuration::destroy_obj

(

ConfigObject &

object

)

Destroy object.

The method tries to destroy given object.

Parameters

object

the object's reference

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 768 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    std::lock_guard<std::mutex> scoped_lock2(m_tmpl_mutex);
    m_impl->destroy(object);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to destroy object \'" << object << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

downcast_dal_object()

template<class T>

void dunedaq::conffwk::Configuration::downcast_dal_object ( const T * obj, bool , std::vector< const DalObject * > & result )

inline

Definition at line 1032 of file Configuration.hpp.

  {
    if (obj)
      result.push_back(obj);
  }

downcast_dal_objects()

template<class T>

void dunedaq::conffwk::Configuration::downcast_dal_objects ( const std::vector< const T * > & objs, bool , std::vector< const DalObject * > & result )

inline

Definition at line 1023 of file Configuration.hpp.

  {
    for (auto& i : objs)
      result.push_back(i);
  }

export_data()

void dunedaq::Configuration::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 = "" )

Export configuration data into ptree.

Parameters

tree	output ptree object
classes	regex defining class names; ignore if empty
objects	regex defining object IDs; ignore if empty
files	regex defining data file names; ignore if empty
empty_array_item	if provided, add this item to mark empty arrays

Exceptions

dunedaq::conffwk::Generic

in case of a problem

Definition at line 1019 of file Configuration.cpp.

{
  std::unique_ptr<std::regex> classes_regex, objects_regex, files_regex;
 
  init_regex(classes_regex, classes_str, "classes");
  init_regex(objects_regex, objects_str, "objects");
  init_regex(files_regex, files_str, "files");
 
  auto cmp_str_ptr = [](const std::string* s1, const std::string* s2) { return *s1 < *s2; };
  std::set<const std::string*, decltype(cmp_str_ptr)> sorted_classes(cmp_str_ptr);
 
  for (const auto& c : superclasses())
    if (classes_str.empty() || std::regex_match(*c.first, *classes_regex.get()))
      sorted_classes.insert(c.first);
 
  for (const auto& c : sorted_classes)
    if (classes_str.empty() || std::regex_match(*c, *classes_regex.get())) {
      const dunedaq::conffwk::class_t& info(get_class_info(*c));
 
      boost::property_tree::ptree pt_objects;
 
      std::vector<ConfigObject> objects;
      get(*c, objects);
 
      auto comp_obj_ptr = [](const ConfigObject* o1, const ConfigObject* o2) { return o1->UID() < o2->UID(); };
      std::set<const ConfigObject*, decltype(comp_obj_ptr)> sorted_objects(comp_obj_ptr);
 
      for (const auto& x : objects)
        if (objects_str.empty() || std::regex_match(x.UID(), *objects_regex.get()))
          if (x.class_name() == *c)
            if (files_str.empty() || std::regex_match(x.contained_in(), *files_regex.get()))
              sorted_objects.insert(&x);
 
      if (!sorted_objects.empty()) {
        boost::property_tree::ptree pt_objects;
 
        for (const auto& x : sorted_objects) {
          boost::property_tree::ptree data;
 
          for (const auto& a : info.p_attributes)
            switch (a.p_type) {
              case dunedaq::conffwk::bool_type:
                add_data<bool>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::s8_type:
                add_data<int8_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::u8_type:
                add_data<uint8_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::s16_type:
                add_data<int16_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::u16_type:
                add_data<uint16_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::s32_type:
                add_data<int32_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::u32_type:
                add_data<uint32_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::s64_type:
                add_data<int64_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::u64_type:
                add_data<uint64_t>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::float_type:
                add_data<float>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::double_type:
                add_data<double>(data, *x, a, empty_array_item);
                break;
              case dunedaq::conffwk::date_type:
              case dunedaq::conffwk::time_type:
              case dunedaq::conffwk::enum_type:
              case dunedaq::conffwk::class_type:
              case dunedaq::conffwk::string_type:
                add_data<std::string>(data, *x, a, empty_array_item);
                break;
              default:
                throw std::runtime_error("Invalid type of attribute " + a.p_name);
            }
 
          for (const auto& r : info.p_relationships)
            add_data(data, *x, r, empty_array_item);
 
          pt_objects.push_back(boost::property_tree::ptree::value_type(x->UID(), data));
        }
 
        pt.put_child(boost::property_tree::ptree::path_type(*c), pt_objects);
      }
    }
}

export_schema()

void dunedaq::Configuration::export_schema	(	boost::property_tree::ptree &	tree,
		const std::string &	classes = "",
		bool	direct_only = false )

Export configuration schema into ptree.

Parameters

tree	output ptree object
classes	regex defining class names; all classes if empty
direct_only	if true is set explicitly, return descriptions of direct attributes, relationships, super- and subclasses; by default return all descriptions taking into account inheritance

Exceptions

dunedaq::conffwk::Generic

in case of a problem

Definition at line 880 of file Configuration.cpp.

{
  std::unique_ptr<std::regex> classes_regex;
 
  init_regex(classes_regex, classes_str, "classes");
 
  auto cmp_str_ptr = [](const std::string* s1, const std::string* s2) { return *s1 < *s2; };
  std::set<const std::string*, decltype(cmp_str_ptr)> sorted_classes(cmp_str_ptr);
 
  for (const auto& c : superclasses())
    if (classes_str.empty() || std::regex_match(*c.first, *classes_regex.get()))
      sorted_classes.insert(c.first);
 
  for (const auto& c : sorted_classes)
    if (classes_str.empty() || std::regex_match(*c, *classes_regex.get())) {
      const dunedaq::conffwk::class_t& info(get_class_info(*c, direct_only));
 
      boost::property_tree::ptree class_pt;
 
      class_pt.put("abstract", info.p_abstract);
      if (!info.p_description.empty())
        class_pt.put("description", info.p_description);
 
      if (!info.p_superclasses.empty()) {
        boost::property_tree::ptree superclasses;
 
        for (const auto& x : info.p_superclasses)
          add_array_item(superclasses, x);
 
        class_pt.add_child("superclasses", superclasses);
      }
 
      if (!info.p_attributes.empty()) {
        boost::property_tree::ptree attributes;
 
        for (const auto& x : info.p_attributes) {
          boost::property_tree::ptree attribute;
 
          attribute.put("type", dunedaq::conffwk::attribute_t::type(x.p_type));
          if (!x.p_range.empty())
            attribute.put("range", x.p_range);
          if (x.p_int_format != dunedaq::conffwk::na_int_format)
            attribute.put("format", dunedaq::conffwk::attribute_t::format2str(x.p_int_format));
          if (x.p_is_not_null)
            attribute.put("is-not-null", x.p_is_not_null);
          if (x.p_is_multi_value)
            attribute.put("is-multi-value", x.p_is_multi_value);
          if (!x.p_default_value.empty())
            attribute.put("default-value", x.p_default_value);
          if (!x.p_description.empty())
            attribute.put("description", x.p_description);
 
          attributes.push_back(boost::property_tree::ptree::value_type(x.p_name, attribute));
        }
 
        class_pt.add_child("attributes", attributes);
      }
 
      if (!info.p_relationships.empty()) {
        boost::property_tree::ptree relationships;
 
        for (const auto& x : info.p_relationships) {
          boost::property_tree::ptree relationship;
 
          relationship.put("type", x.p_type);
          relationship.put("cardinality", dunedaq::conffwk::relationship_t::card2str(x.p_cardinality));
          if (!x.p_is_aggregation)
            relationship.put("is-aggregation", x.p_is_aggregation);
          if (!x.p_description.empty())
            relationship.put("description", x.p_description);
 
          relationships.push_back(boost::property_tree::ptree::value_type(x.p_name, relationship));
        }
 
        class_pt.add_child("relationships", relationships);
      }
 
      pt.put_child(boost::property_tree::ptree::path_type(*c), class_pt);
    }
}

find()

template<class T>

const T * dunedaq::conffwk::Configuration::find ( const std::string & id )

inline

Find object of given class (multi-thread safe).

Could be used for generated template objects.

Parameters

id	ID of object

Returns

Return pointer to object or nullptr if there is no such object

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 841 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _find<T>(id);
  }

find_callback()

Configuration::CallbackSubscription * dunedaq::Configuration::find_callback ( CallbackId cb_handler ) const

private

Definition at line 1163 of file Configuration.cpp.

{
  return ((!cb_handler || (m_callbacks.find(cb_handler) == m_callbacks.end())) ? 0 : cb_handler);
}

find_class_domains()

std::deque< std::set< std::string > > dunedaq::Configuration::find_class_domains ( )

private

Definition at line 647 of file Configuration.cpp.

{
  std::deque<std::set<std::string>> domains;
 
  std::deque<dunedaq::conffwk::class_t> seeds;
  for (const auto& c : get_class_list()) {
    auto ci = this->_get_class_info(c);
    if (ci.p_superclasses.empty())
      seeds.push_back(ci);
  }
 
  for (const auto& ci : seeds) {
    // Make a candidate domain based using the seed subclasses
    std::set<std::string> class_domain;
    class_domain.insert(ci.p_name);
    class_domain.insert(ci.p_subclasses.begin(), ci.p_subclasses.end());
 
    // Look for overlaps with other domains
    std::deque<std::set<std::string>> overlapping;
    for (auto& d : domains) {
      std::set<std::string> intersection;
      std::set_intersection(d.begin(),
                            d.end(),
                            class_domain.begin(),
                            class_domain.end(),
                            std::inserter(intersection, intersection.begin()));
      // non-zero intersection, overlap found
      if (intersection.size() > 0) {
        overlapping.push_back(d);
      }
    }
 
    // If overlapping are found, add all overlapping to
    // the new domain and remove them from the domain list
    if (!overlapping.empty()) {
      for (auto& d : overlapping) {
        // merge the existing cluster in class_domain
        class_domain.insert(d.begin(), d.end());
        // Remove the old cluster from the list
        auto it = std::find(domains.begin(), domains.end(), d);
        if (it != domains.end()) {
          domains.erase(it);
        }
      }
    }
 
    domains.push_back(class_domain);
  }
 
  return domains;
}

get() [1/7]

template<class T>

const T * dunedaq::conffwk::Configuration::get ( ConfigObject & obj, bool init_children = false, bool init = true )

inline

Get object of given class by object reference and instantiate the template parameter with it (multi-thread safe).

Such method to be used for user classes generated by the genconffwk utility.

Parameters

obj	reference to conffwk object, that is used to instantiate template object
init_children	if true, the referenced objects are initialized
init	if true, the object's attributes and relationships are read

Returns

Return pointer to object.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 771 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _get<T>(obj, init_children, init);
  }

get() [2/7]

template<class T>

const T * dunedaq::conffwk::Configuration::get ( ConfigObject & obj, const std::string & id )

inline

Generate object of given class by object reference and instantiate the template parameter with it (multi-thread safe).

Such method to be used to generate template objects.

Parameters

obj	reference to conffwk object, that is used to instantiate template object
id	ID of generated object could be different from obj.UID()

Returns

Return pointer to object.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 822 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _get<T>(obj, id);
  }

get() [3/7]

void dunedaq::Configuration::get	(	const ConfigObject &	obj_from,
		const std::string &	query,
		std::vector< ConfigObject > &	objects,
		unsigned long	rlevel = 0,
		const std::vector< std::string > *	rclasses = 0 )

Get path between objects.

The method returns all objects which are in the path starting from source object matching to the path query pattern.

Parameters

obj_from	object to start from
query	path query
objects	returned value in case of success
rlevel	optional references level to optimize performance (defines how many objects referenced by found objects have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 282 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    m_impl->get(obj_from, query, objects, rlevel, rclasses);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to get path \'" << query << "\' from object \'" << obj_from << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

get() [4/7]

void dunedaq::Configuration::get	(	const std::string &	class_name,
		const std::string &	id,
		ConfigObject &	object,
		unsigned long	rlevel = 0,
		const std::vector< std::string > *	rclasses = 0 )

Get object by class name and object id (multi-thread safe).

The method searches an object with given id within the class and all derived subclasses.

Parameters

class_name	name of the class
id	object identity
object	returned value in case of success
rlevel	optional references level to optimize performance (defines how many objects referenced by given object have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Exceptions

dunedaq::conffwk::NotFound

exception if there is no such object or dunedaq::conffwk::Generic in case of an error

Definition at line 235 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
  _get(class_name, id, object, rlevel, rclasses);
}

get() [5/7]

void dunedaq::Configuration::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 )

Get all objects of class.

The method returns all objects of given class and objects of subclasses derived from it.

Parameters

class_name	name of the class
objects	returned value in case of success
query	optional parameter defining selection criteria for objects of given class
rlevel	optional references level to optimize performance (defines how many objects referenced by found objects have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Exceptions

dunedaq::conffwk::NotFound

exception if there is no such class or dunedaq::conffwk::Generic in case of an error

Definition at line 262 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    m_impl->get(class_name, objects, query, rlevel, rclasses);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to get objects of class \'" << class_name << '\'';
    if (!query.empty()) {
      text << " with query \'" << query << '\'';
    }
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

get() [6/7]

template<class T>

const T * dunedaq::conffwk::Configuration::get ( const std::string & id, bool init_children = false, bool init = true, unsigned long rlevel = 0, const std::vector< std::string > * rclasses = 0 )

inline

Get object of given class by identity and instantiate the template parameter with it (multi-thread safe).

Such method to be used for user classes generated by the genconffwk utility.

Parameters

id	object identity
init_children	if true, the referenced objects are initialized
init	if true, the object's attributes and relationships are read
rlevel	optional references level to optimize performance (defines how many objects referenced by given object have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Returns

Return 0 if there is no object with such id or pointer to object otherwise.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 745 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _get<T>(id, init_children, init, rlevel, rclasses);
  }

get() [7/7]

template<class T>

void dunedaq::conffwk::Configuration::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 )

inline

Get all objects of given class and instantiate a vector of the template parameters object with it (multi-thread safe).

Such method to be used for user classes generated by the genconffwk utility.

Parameters

objects	the vector is filled by the method
init_children	if true, the referenced objects are initialized
init	if true, the object's attributes and relationships are read
query	optional parameter defining selection criteria for objects of given class
rlevel	optional references level to optimize performance (defines how many objects referenced by found objects have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Exceptions

dunedaq::conffwk::Generic

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

Definition at line 796 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    _get<T>(objects, init_children, init, query, rlevel, rclasses);
  }

get_changes()

std::vector< dunedaq::conffwk::Version > dunedaq::Configuration::get_changes

(

)

Get new conffwk versions.

Returns

repository changes: new versions created on remote origin after current HEAD version, or externally modified files

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 1128 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    return m_impl->get_changes();
  } catch (dunedaq::conffwk::Generic& ex) {
    throw dunedaq::conffwk::Generic(ERS_HERE, "failed to get new versions", ex);
  }
}

get_class_info()

const dunedaq::conffwk::class_t & dunedaq::Configuration::get_class_info	(	const std::string &	class_name,
		bool	direct_only = false )

The method provides access to description of class.

Parameters

class_name	name of the class
direct_only	if true is set explicitly, return descriptions of direct attributes, relationships, super- and subclasses; by default return all descriptions taking into account inheritance

Returns

Return pointer to class description object.

Exceptions

dunedaq::conffwk::NotFound

exception if there is no class with such name or dunedaq::conffwk::Generic in case of a problem

Definition at line 824 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  return this->_get_class_info(class_name, direct_only);
}

get_class_list()

std::vector< std::string > dunedaq::Configuration::get_class_list

(

)

const

Definition at line 1877 of file Configuration.cpp.

{
  std::vector<std::string> classes;
  for (const auto& it : this->superclasses()) {
    classes.push_back(*it.first);
  }
 
  return classes;
}

get_impl_name()

const std::string & dunedaq::conffwk::Configuration::get_impl_name ( ) const

inlinenoexcept

Get implementation plug-in name used to build conffwk object

Definition at line 268 of file Configuration.hpp.

{ return m_impl_name; }

get_impl_param()

const std::string & dunedaq::conffwk::Configuration::get_impl_param ( ) const

inlinenoexcept

Get implementation plug-in parameter used to build conffwk object

Definition at line 272 of file Configuration.hpp.

{ return m_impl_param; }

get_impl_spec()

const std::string & dunedaq::conffwk::Configuration::get_impl_spec ( ) const

inlinenoexcept

Get implementation plug-in and it's parameter used to build conffwk object

Definition at line 264 of file Configuration.hpp.

{ return m_impl_spec; }

get_includes()

void dunedaq::Configuration::get_includes	(	const std::string &	db_name,
		std::list< std::string > &	includes ) const

Get include files.

The method returns list of files included by given database.

Parameters

db_name	name of database file
includes	returned list of include files

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 493 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  try {
    m_impl->get_includes(db_name, includes);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to get includes of database \'" << db_name << '\'';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex));
  }
}

get_obj_pybind()

ConfigObject * dunedaq::Configuration::get_obj_pybind	(	const std::string &	class_name,
		const std::string &	id )

Definition at line 1906 of file Configuration.cpp.

{
  auto co = new ConfigObject;
  this->get(class_name, id, *co);
  if (co->is_null()) {
    delete co;
    co = nullptr;
  }
  return co;
}

get_objs_pybind()

std::vector< ConfigObject > * dunedaq::Configuration::get_objs_pybind	(	const std::string &	class_name,
		const std::string &	query = "" )

Definition at line 1918 of file Configuration.cpp.

{
  auto objs = new std::vector<ConfigObject>;
  this->get(class_name, *objs, query);
  return objs;
}

get_schema_path_pybind()

const std::string & dunedaq::Configuration::get_schema_path_pybind ( const std::string & class_name )

nodiscard

Definition at line 1978 of file Configuration.cpp.

{
  const dunedaq::conffwk::class_t& c = this->get_class_info(class_name, false);
  return c.p_schema_path;
}

get_updated_dbs()

void dunedaq::Configuration::get_updated_dbs

(

std::list< std::string > &

dbs

)

const

Get list of updated files to be committed.

The method returns list of uncommitted database files.

Parameters

dbs	returned list of uncommitted database files

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 510 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  try {
    m_impl->get_updated_dbs(dbs);
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, "get_updated_dbs failed", ex));
  }
}

get_versions()

std::vector< dunedaq::conffwk::Version > dunedaq::Configuration::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 )

Get repository versions in interval.

Access historical versions.

The date/time format has to be either a date in format "yyyy-mm-dd" or date-and-time in format "yyyy-mm-dd hh:mm:ss" (UTC).

Parameters

since	limit the versions committed on-or-after the specified hash key, tag or date/time; if empty, start from earliest available
until	limit the versions committed on-or-before the specified hash key, tag or date/time; if empty, retrieve all versions until latest available
type	define query type
skip_irrelevant	if true, ignore changes not affecting loaded configuration

Returns

repository versions satisfying query

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 1139 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    return m_impl->get_versions(since, until, type, skip_irrelevant);
  } catch (dunedaq::conffwk::Generic& ex) {
    throw dunedaq::conffwk::Generic(ERS_HERE, "failed to get versions", ex);
  }
}

is_superclass_of() [1/2]

bool dunedaq::conffwk::Configuration::is_superclass_of ( const std::string & target, const std::string & source )

noexcept

is_superclass_of() [2/2]

bool dunedaq::conffwk::Configuration::is_superclass_of ( const std::string * target, const std::string * source )

noexcept

is_valid()

template<class T>

bool dunedaq::conffwk::Configuration::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 276 of file Configuration.hxx.

{
  // 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);
}

is_writable()

bool dunedaq::Configuration::is_writable

(

const std::string &

db_name

)

const

Get write access status.

Check if given database file is writable by current user.

Parameters

db_name

name of database

Returns

true, if database file is writable and false otherwise.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 435 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw(dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded"));
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  try {
    return m_impl->is_writable(db_name);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to get write access status for database \'" << db_name << '\'';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex));
  }
}

load()

void dunedaq::Configuration::load

(

const std::string &

db_name

)

Load database according to the name. If name is empty, take it from TDAQ_DB_NAME and TDAQ_DB_DATA environment variables.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 305 of file Configuration.cpp.

{
  std::string name;
 
  if (db_name.empty()) {
    if (!m_impl_spec.empty() && !m_impl_param.empty()) {
      name = m_impl_param;
    } else {
      const char* s = ::getenv("TDAQ_DB_NAME");
      if (s == 0 || *s == 0)
        s = ::getenv("TDAQ_DB_DATA");
 
      if (s && *s) {
        name = s;
      } else {
        throw(dunedaq::conffwk::Generic(ERS_HERE, "no database name was provided"));
      }
    }
  } else {
    name = db_name;
  }
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  // call conffwk actions if any
  {
    std::lock_guard<std::mutex> scoped_lock(m_actn_mutex);
    for (auto& i : m_actions) {
      i->load();
    }
  }
 
  if (m_impl) {
    m_impl->open_db(name);
    // m_impl->get_superclasses(p_superclasses);
    // set_subclasses();
    update_classes();
    m_impl->set(this);
 
    if (check_prefetch_needs()) {
      m_impl->prefetch_all_data();
    }
 
    TLOG_DEBUG(2) << "\n*** DUMP CONFIGURATION ***\n" << *this;
  } else {
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
  }
}

loaded()

bool dunedaq::Configuration::loaded ( ) const

noexcept

Check if database is correctly loaded.

Check state of the database after configuration object creation.

Returns

true if the database was successfully loaded and false otherwise.

Definition at line 299 of file Configuration.cpp.

{
  return (m_impl != nullptr) ? m_impl->loaded() : false;
}

mk_ref_by_ex_text()

std::string dunedaq::Configuration::mk_ref_by_ex_text ( const std::string & cname, const std::string & rname, const ConfigObject & obj )

staticprivatenoexcept

Helper method to prepare exception text when template referenced_by() method fails

Definition at line 1798 of file Configuration.cpp.

{
  std::ostringstream text;
  text << "failed to get objects of class \'" << cname << "\' referencing object \'" << obj << "\' via relationship \'"
       << rname << '\'';
  return text.str();
}

mk_ref_ex_text()

std::string dunedaq::Configuration::mk_ref_ex_text ( const char * what, const std::string & cname, const std::string & rname, const ConfigObject & obj )

staticprivatenoexcept

Helper method to prepare exception text when template ref() method fails

Definition at line 1786 of file Configuration.cpp.

{
  std::ostringstream text;
  text << "failed to get " << what << " of class \'" << cname << "\' via relationship \'" << rname << "\' of object \'"
       << obj << '\'';
  return text.str();
}

operator=()

Configuration & dunedaq::conffwk::Configuration::operator= ( const Configuration & )

private

prefetch_all_data()

void dunedaq::Configuration::prefetch_all_data

(

)

Prefetch all data into client cache.

The method reads all objects defined in database into client cache.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 582 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock1(m_tmpl_mutex); // always lock template objects mutex first
  std::lock_guard<std::mutex> scoped_lock2(m_impl_mutex);
 
  try {
    m_impl->prefetch_all_data();
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, "prefetch all data failed", ex));
  }
}

print()

void dunedaq::Configuration::print ( std::ostream & s ) const

noexcept

Prints out details of configuration object.

For the moment only inheritance hierarchy of configuration database is printed. In future it is planned to add more details, such as:

• conffwk objects
• status of template cache
• profiling info

Definition at line 1688 of file Configuration.cpp.

{
  s << "Configuration object:\n  Inheritance Hierarchy (class - all it's superclasses):\n";
 
  for (const auto& i : p_superclasses) {
    s << "  * \'" << *i.first << "\' - ";
    if (i.second.empty())
      s << "(null)";
    else
      for (auto j = i.second.begin(); j != i.second.end(); ++j) {
        if (j != i.second.begin())
          s << ", ";
        s << '\'' << **j << '\'';
      }
    s << std::endl;
  }
}

print_profiling_info()

void dunedaq::Configuration::print_profiling_info ( )

noexcept

Print out profiling information.

The method prints out to the standard output stream profiling information of configuration object and it's implementation.

Definition at line 178 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  std::cout << "Configuration profiler report:\n"
               "  number of created template objects: "
            << p_number_of_template_object_created
            << "\n"
               "  number of read template objects: "
            << p_number_of_template_object_read
            << "\n"
               "  number of cache hits: "
            << p_number_of_cache_hits << std::endl;
 
  // FIXME: re-implement for the dal registry
  // const char * s = ::getenv("TDAQ_DUMP_CONFFWK_PROFILER_INFO");
  // if (s && !strcmp(s, "DEBUG"))
  //   {
  //     std::cout << "  Details of accessed objects:\n";
 
  //     for (auto & i : m_cache_map)
  //       {
  //         Cache<DalObject> *c = static_cast<Cache<DalObject>*>(i.second);
  //         std::cout << "    *** " << c->m_cache.size() << " objects is class \'" << *i.first << "\' were accessed
  //         ***\n"; for (auto & j : c->m_cache)
  //           std::cout << "     - object \'" << j.first << '\'' << std::endl;
  //       }
  //   }
 
  if (m_impl) {
    m_impl->print_cache_info();
    m_impl->print_profiling_info();
  }
}

ref() [1/2]

template<class T>

const T * dunedaq::conffwk::Configuration::ref ( ConfigObject & obj, const std::string & name, bool init = false )

inline

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 865 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    return _ref<T>(obj, name, init);
  }

ref() [2/2]

template<class T>

void dunedaq::conffwk::Configuration::ref ( ConfigObject & obj, const std::string & name, std::vector< const T * > & objects, bool init = false )

inline

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 886 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    _ref<T>(obj, name, objects, init);
  }

referenced_by() [1/2]

std::vector< const DalObject * > dunedaq::conffwk::Configuration::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 )

Get DAL objects holding references on this object via given relationship (multi-thread safe).

The method returns vector of DalObject, which have references on given object via explicitly provided relationship name. If the relationship name is set to "*", then the method takes into account all relationships of all objects.

It is expected that the DAL for returned objects is generated and linked with user code. If this is not the case, then an exception will be thrown. The parameter upcast_unregistered allows to select one of the registered base classes instead. Note, this will be a random base class, not the closest based one.

The method is efficient only for composite relationships (i.e. when a parent has composite reference on this object). For generic relationships the method performs full scan of all database objects. It is not recommended at large scale to build complete graph of relations between all database object.

Parameters

obj	object
relationship_name	name of the relationship, via which the object is referenced
upcast_unregistered	if true, try to upcast objects of classes which DAL classes are not loaded; otherwise throw exception if such DAL class is not registered
check_composite_only	only returned composite parent objects
init	if true, the returned objects and their referenced objects are initialized
rlevel	optional references level to optimize performance (defines how many objects referenced by found objects have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Returns

objects referencing given one

Exceptions

dunedaq::conffwk::Generic

in case of an error

referenced_by() [2/2]

template<class T, class V>

void dunedaq::conffwk::Configuration::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 )

Get template DAL objects holding references on this object via given relationship (multi-thread safe).

The method returns objects of class V, which have references on given object via explicitly provided relationship name. If the relationship name is set to "*", then the method takes into account all relationships of all objects. The method is efficient only for composite relationships (i.e. when a parent has composite reference on this object). For generic relationships the method performs full scan of all database objects. It is not recommended at large scale to build complete graph of relations between all database object.

Parameters

obj	object
objects	returned value
relationship_name	name of the relationship, via which the object is referenced
check_composite_only	only returned composite parent objects
init	if true, the returned objects and their referenced objects are initialized
rlevel	optional references level to optimize performance (defines how many objects referenced by found objects have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 143 of file Configuration.hxx.

{
  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));
  }
}

register_converter()

template<class T>

void dunedaq::conffwk::Configuration::register_converter ( AttributeConverter< T > * object )

noexcept

Register user function for attribute conversion.

The user can register several objects which are used for attribute values conversion. The attributes conversion type is defined by the template parameter, e.g. given object to be used for string attribute values conversion, another object to be used for short unsigned integers, etc. It is possible to define several converters for each type. There is no check that given object was already registered or not. It is registered several times, the conversion will be done several times.

Parameters

object

the converter object

Definition at line 373 of file Configuration.hxx.

{
  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);
}

relations_pybind()

std::unordered_map< std::string, std::unordered_map< std::string, std::string > > dunedaq::Configuration::relations_pybind	(	const std::string &	class_name,
		bool	all )

Definition at line 1926 of file Configuration.cpp.

{
 
  std::unordered_map<std::string, std::unordered_map<std::string, std::string>> all_relationships_properties;
 
  const dunedaq::conffwk::class_t& c = this->get_class_info(class_name, !all);
 
  for (const auto& rp : c.p_relationships) {
    std::unordered_map<std::string, std::string> relationship_properties;
 
    relationship_properties["type"] = rp.p_type;
    relationship_properties["description"] = rp.p_description;
    relationship_properties["multivalue"] =
      (rp.p_cardinality == dunedaq::conffwk::zero_or_many || rp.p_cardinality == dunedaq::conffwk::one_or_many)
        ? "True"
        : "False";
    relationship_properties["aggregation"] = rp.p_is_aggregation ? "True" : "False";
    relationship_properties["not-null"] =
      (rp.p_cardinality == dunedaq::conffwk::only_one || rp.p_cardinality == dunedaq::conffwk::one_or_many) ? "True"
                                                                                                            : "False";
 
    all_relationships_properties[rp.p_name] = relationship_properties;
  }
 
  return all_relationships_properties;
}

remove_action()

void dunedaq::Configuration::remove_action

(

ConfigAction *

ac

)

Remove global action performed by user code on db [un]load and updates.

Definition at line 68 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_actn_mutex);
  m_actions.remove(ac);
}

remove_include()

void dunedaq::Configuration::remove_include	(	const std::string &	db_name,
		const std::string &	include )

Remove include file.

The method removes existing include file from the database.

Parameters

db_name	name of database file from which the include to be removed
include	file to be removed from includes

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 472 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
  std::lock_guard<std::mutex> scoped_lock2(m_tmpl_mutex);
 
  try {
    m_impl->remove_include(db_name, include);
    // m_impl->get_superclasses(p_superclasses);
    // set_subclasses();
    update_classes();
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to remove include \'" << include << "\' from database \'" << db_name << '\'';
    throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex));
  }
}

rename_object()

void dunedaq::Configuration::rename_object ( ConfigObject & obj, const std::string & new_id )

private

Cache of template object of given type.

The class defines the cache of template objects of given type. The objects are stored in cache, where the key is object-ID and the value is a pointer on template object.

The access to cache and objects insertion are provided via two get() methods:

• T * get(Configuration&, ConfigObject&, bool, bool) - get template object for given conffwk object
• T * get(Configuration&, const std::string&, bool, bool, unsigned long, const std::vector<std::string> *) - get template object for given object ID

Definition at line 782 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_impl_lock(m_tmpl_mutex); // always lock template objects mutex first
  std::lock_guard<std::mutex> scoped_tmpl_lock(m_impl_mutex);
 
  std::lock_guard<std::mutex> scoped_obj_lock(obj.m_impl->m_mutex);
 
  const std::string old_id(obj.m_impl->m_id);
 
  obj.m_impl->throw_if_deleted();
  obj.m_impl->rename(new_id);
  obj.m_impl->m_id = new_id;
  m_impl->rename_impl_object(obj.m_impl->m_class_name, old_id, new_id);
 
  TLOG_DEBUG(3) << " * call rename \'" << old_id << "\' to \'" << new_id << "\' in class \'" << obj.class_name()
                << "\')";
 
  m_registry._rename_object(obj.class_name(), old_id, new_id);
 
  // conffwk::fmap<CacheBase*>::iterator j = m_cache_map.find(&obj.class_name());
  // if (j != m_cache_map.end())
  //   j->second->m_functions.m_rename_object_fn(j->second, old_id, new_id);
 
  // conffwk::fmap<conffwk::fset>::const_iterator sc = p_superclasses.find(&obj.class_name());
 
  // if (sc != p_superclasses.end())
  //   for (conffwk::fset::const_iterator c = sc->second.begin(); c != sc->second.end(); ++c)
  //     {
  //       conffwk::fmap<CacheBase*>::iterator j = m_cache_map.find(*c);
 
  //       if (j != m_cache_map.end())
  //         j->second->m_functions.m_rename_object_fn(j->second, old_id, new_id);
  //     }
}

reset_subscription()

void dunedaq::Configuration::reset_subscription ( )

private

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 1262 of file Configuration.cpp.

{
  // check that there is no at least one subscription
  // if NO, then unsubscribe
 
  if (m_callbacks.empty()) {
    m_impl->unsubscribe();
    return;
  }
 
  // prepare subscription criteria
 
  ConfigurationSubscriptionCriteria::ObjectMap obj_subscriptions;
  std::set<std::string> class_subscriptions;
 
  // among existing subscriptions find one who has all subscriptions
 
  bool found_subscribe_all = false;
 
  for (const auto& i : m_callbacks)
    if (i->m_criteria.get_classes_subscription().empty() && i->m_criteria.get_objects_subscription().empty()) {
      found_subscribe_all = true;
      break;
    }
 
  if (found_subscribe_all == false) {
    // build list of all classes for which there is a subscription
    for (const auto& i : m_callbacks)
      for (const auto& j : i->m_criteria.get_classes_subscription())
        class_subscriptions.insert(j);
 
    // build list of all objects for which there is a subscription (if there is no such class)
    for (const auto& i : m_callbacks)
      for (const auto& j : i->m_criteria.get_objects_subscription()) {
        const std::string& obj_class_name = j.first;
        if (class_subscriptions.find(obj_class_name) == class_subscriptions.end())
          for (const auto& k : j.second)
            obj_subscriptions[obj_class_name].insert(k);
      }
  }
 
  m_impl->subscribe(class_subscriptions, obj_subscriptions, system_cb, system_pre_cb);
}

return_includes_pybind()

std::list< std::string > * dunedaq::Configuration::return_includes_pybind

(

const std::string &

db_name

)

Definition at line 1954 of file Configuration.cpp.

{
  auto l = new std::list<std::string>;
  this->get_includes(db_name, *l);
  return l;
}

set_class_domain_map()

void dunedaq::Configuration::set_class_domain_map ( )

private

Definition at line 700 of file Configuration.cpp.

{
 
  p_class_domain_map.clear();
 
  auto domains = this->find_class_domains();
  for (size_t i(0); i < domains.size(); ++i) {
    const auto& dom = domains[i];
    for (const auto& class_name : dom) {
      p_class_domain_map[&conffwk::DalFactory::instance().get_known_class_name_ref(class_name)] = i;
    }
  }
}

set_commit_credentials()

void dunedaq::Configuration::set_commit_credentials	(	const std::string &	user,
		const std::string &	password )

Set commit credentials.

The method sets credentials used by commit method.

Parameters

user	user name
password	user password

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 525 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "no implementation loaded");
 
  std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
 
  try {
    m_impl->set_commit_credentials(user, password);
  } catch (dunedaq::conffwk::Generic& ex) {
    throw(dunedaq::conffwk::Generic(ERS_HERE, "set_commit_credentials failed", ex));
  }
}

set_subclasses()

void dunedaq::Configuration::set_subclasses ( )

privatenoexcept

Definition at line 628 of file Configuration.cpp.

{
  p_subclasses.clear();
 
  for (const auto& i : p_superclasses)
    for (const auto& j : i.second)
      p_subclasses[j].insert(i.first);
}

subclasses()

const conffwk::fmap< conffwk::fset > & dunedaq::conffwk::Configuration::subclasses ( ) const

inline

Get names of subclasses for each class

Definition at line 1462 of file Configuration.hpp.

{ return p_subclasses; }

subclasses_pybind()

std::vector< std::string > dunedaq::Configuration::subclasses_pybind	(	const std::string &	class_name,
		bool	all )

Definition at line 1962 of file Configuration.cpp.

{
 
  const dunedaq::conffwk::class_t& c = this->get_class_info(class_name, !all);
  return c.p_subclasses;
}

subscribe() [1/2]

CallbackId dunedaq::conffwk::Configuration::subscribe	(	const ConfigurationSubscriptionCriteria &	criteria,
		notify	user_cb,
		void *	user_param = nullptr )

Subscribe on configuration changes.

The method is used to make a subscription. The returned value is a subscription handler.

When subscribed changes occurred, the user callback function is invoked with changes description and parameter 'user_param' defined by user.

Parameters

criteria	subscription criteria
user_cb	user-defined callback function
user_param	optional user-defined parameter

Returns

non-null value in case of success (the value to be used for unsubscribe() method).

Exceptions

dunedaq::conffwk::Generic

in case of an error

subscribe() [2/2]

CallbackId dunedaq::conffwk::Configuration::subscribe	(	pre_notify	user_cb,
		void *	user_param = nullptr )

Subscribe on pre-notification on configuration changes.

The method is used to make complimentary subscription on pre-notification about changes, that can only be used together with real subscription on changes, i.e. using subscribe(const ConfigurationSubscriptionCriteria&, notify, void *) method.

When subscribed changes occurred, but before they are going to be applied, the user callback function is invoked with parameter 'user_param' defined by user. This subscription can be used to be informed, that some changes are took place already and will be applied immediately after user's code exits given callback function.

Parameters

user_cb	user-defined callback function
user_param	optional user-defined parameter

Returns

non-null value in case of success (the value to be used for unsubscribe() method).

Exceptions

dunedaq::conffwk::Generic

in case of an error

superclasses()

const conffwk::fmap< conffwk::fset > & dunedaq::conffwk::Configuration::superclasses ( ) const

inlinenoexcept

Get names of superclasses for each class

Definition at line 1458 of file Configuration.hpp.

{ return p_superclasses; }

superclasses_pybind()

std::vector< std::string > dunedaq::Configuration::superclasses_pybind	(	const std::string &	class_name,
		bool	all )

Definition at line 1970 of file Configuration.cpp.

{
 
  const dunedaq::conffwk::class_t& c = this->get_class_info(class_name, !all);
  return c.p_superclasses;
}

system_cb()

void dunedaq::Configuration::system_cb ( std::vector< ConfigurationChange * > & changes, Configuration * conf )

staticnoexcept

System callback function invoked in case of modifications.

It is used by the database implementation. Only is called, when a user subscription to related class is set.

Definition at line 1457 of file Configuration.cpp.

{
 
  TLOG_DEBUG(3) << "*** Enter Configuration::system_cb()\n"
                   "*** Number of user subscriptions: "
                << conf->m_callbacks.size();
 
  // call conffwk actions if any
  {
    std::lock_guard<std::mutex> scoped_lock(conf->m_impl_mutex);
    std::lock_guard<std::mutex> scoped_lock2(conf->m_actn_mutex);
    for (auto& i : conf->m_actions)
      i->notify(changes);
  }
 
  // update template objects in cache
  {
    std::lock_guard<std::mutex> scoped_lock(conf->m_tmpl_mutex); // always lock template objects mutex first
    std::lock_guard<std::mutex> scoped_lock2(conf->m_impl_mutex);
    conf->update_cache(changes);
  }
 
  // user removed all subscriptions
  if (conf->m_callbacks.empty())
    return;
 
  // note, one cannot lock m_tmpl_mutex or m_impl_mutex here,
  // since user callback may call arbitrary get() methods to access conffwk
  // and template objects locking above two mutexes
  std::lock_guard<std::mutex> scoped_lock(conf->m_else_mutex);
 
  // check if there is only one subscription
  if (conf->m_callbacks.size() == 1) {
    auto j = *conf->m_callbacks.begin();
    (*(j->m_cb))(changes, j->m_param);
  }
  // may need to calculate the changes for each subscription
  else {
    for (const auto& j : conf->m_callbacks) {
 
      if (ers::debug_level() >= 3) {
        std::ostringstream text;
 
        text << "*** Process subscription " << (void*)j
             << "\n"
                " class subscription done for "
             << j->m_criteria.get_classes_subscription().size() << " classes:\n";
 
        for (const auto& i1 : j->m_criteria.get_classes_subscription())
          text << " * class \"" << i1 << "\"\n";
 
        text << " object subscription done in " << j->m_criteria.get_objects_subscription().size() << " classes:\n";
 
        for (const auto& i2 : j->m_criteria.get_objects_subscription()) {
          text << " * class \"" << (i2.first) << "\":\n";
          for (const auto& i3 : i2.second)
            text << "  - \"" << i3 << "\"\n";
        }
 
        TLOG_DEBUG(3) << text.str();
      }
 
      if (j->m_criteria.get_classes_subscription().empty() && j->m_criteria.get_objects_subscription().empty()) {
        try {
          TLOG_DEBUG(3) << "*** Invoke callback " << (void*)j << " with\n" << changes;
          (*(j->m_cb))(changes, j->m_param);
        } catch (const ers::Issue& ex) {
          ers::error(dunedaq::conffwk::Generic(ERS_HERE, "user callback thrown ers exception", ex));
        } catch (const std::exception& ex) {
          ers::error(dunedaq::conffwk::Generic(ERS_HERE, "user callback thrown std exception", ex));
        } catch (...) {
          ers::error(dunedaq::conffwk::Generic(ERS_HERE, "user callback thrown unknown exception"));
        }
      } else {
        std::vector<ConfigurationChange*> changes1;
 
        for (const auto& i : changes) {
          const std::string& cname = i->get_class_name();
          ConfigurationChange* class_changes = nullptr;
 
          ConfigurationSubscriptionCriteria::ObjectMap::const_iterator p =
            j->m_criteria.get_objects_subscription().find(cname);
          const bool found_obj_subscription(p != j->m_criteria.get_objects_subscription().end());
          const bool found_class_subscription(j->m_criteria.get_classes_subscription().find(cname) !=
                                              j->m_criteria.get_classes_subscription().end());
 
          if (found_class_subscription || found_obj_subscription)
            class_changes = new ConfigurationChange(cname);
 
          if (found_class_subscription) {
            for (const auto& k : i->m_modified)
              class_changes->m_modified.push_back(k);
 
            for (const auto& k : i->m_created)
              class_changes->m_created.push_back(k);
 
            for (const auto& k : i->m_removed)
              class_changes->m_removed.push_back(k);
          }
 
          if (found_obj_subscription) {
            for (const auto& obj_id : i->m_modified)
              if (p->second.find(obj_id) != p->second.end())
                class_changes->m_modified.push_back(obj_id);
 
            for (const auto& obj_id : i->m_removed)
              if (p->second.find(obj_id) != p->second.end())
                class_changes->m_removed.push_back(obj_id);
          }
 
          // the changes for given class can be empty if there is subscription on objects of given class, but no such
          // objects were modified
          if (class_changes) {
            if (class_changes->m_modified.empty() && class_changes->m_created.empty() &&
                class_changes->m_removed.empty())
              delete class_changes;
            else
              changes1.push_back(class_changes);
          }
        }
 
        if (!changes1.empty()) {
          TLOG_DEBUG(3) << "*** Invoke callback " << (void*)j << " with\n" << changes1;
 
          try {
            (*(j->m_cb))(changes1, j->m_param);
          } catch (const ers::Issue& ex) {
            ers::error(dunedaq::conffwk::Generic(ERS_HERE, "user callback thrown ers exception", ex));
          } catch (const std::exception& ex) {
            ers::error(dunedaq::conffwk::Generic(ERS_HERE, "user callback thrown std exception", ex));
          } catch (...) {
            ers::error(dunedaq::conffwk::Generic(ERS_HERE, "user callback thrown unknown exception"));
          }
 
          for (const auto& i : changes1)
            delete i;
        }
      }
    }
  }
 
  TLOG_DEBUG(3) << "*** Leave Configuration::system_cb()";
}

system_pre_cb()

void dunedaq::Configuration::system_pre_cb ( Configuration * conf )

staticnoexcept

System callback function invoked in case of pre-modifications.

It is used by the database implementation. Only is called, when a user subscription is set.

Definition at line 1602 of file Configuration.cpp.

{
  TLOG_DEBUG(3) << "*** Enter Configuration::system_pre_cb()";
 
  std::lock_guard<std::mutex> scoped_lock(conf->m_else_mutex);
 
  for (auto& j : conf->m_pre_callbacks) {
    TLOG_DEBUG(3) << "*** Invoke callback " << (void*)(j);
    (*(j->m_cb))(j->m_param);
  }
 
  TLOG_DEBUG(3) << "*** Leave Configuration::system_pre_cb()";
}

test_object()

bool dunedaq::Configuration::test_object	(	const std::string &	class_name,
		const std::string &	id,
		unsigned long	rlevel = 0,
		const std::vector< std::string > *	rclasses = 0 )

Test the object existence.

The method searches an object with given id within the class and all derived subclasses. If found, the method returns true, otherwise the method return false.

Parameters

class_name	name of the class
id	object identity
rlevel	optional references level to optimize performance (defines how many objects referenced by given object have also to be read to the implementation cache)
rclasses	optional array of class names to optimize performance (defines which referenced objects have to be read to the implementation cache)

Exceptions

dunedaq::conffwk::Generic

if there is no such class or in case of an error

Definition at line 723 of file Configuration.cpp.

{
  try {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    return m_impl->test_object(class_name, id, rlevel, rclasses);
  } catch (dunedaq::conffwk::Generic& ex) {
    std::ostringstream text;
    text << "failed to test existence of object \'" << id << '@' << class_name << '\'';
    throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str(), ex);
  }
}

try_cast() [1/2]

bool dunedaq::Configuration::try_cast ( const std::string & target, const std::string & source )

noexcept

Checks if cast from source class to target class is allowed.

Parameters

target	name of desired class (e.g. try to cast object of "source" class to this "target" one)
source	name of casted object class

Returns

Return true if the cast is allowed by database schema

Definition at line 1707 of file Configuration.cpp.

{
  return is_superclass_of(target, source);
}

try_cast() [2/2]

bool dunedaq::Configuration::try_cast ( const std::string * target, const std::string * source )

noexcept

Definition at line 1713 of file Configuration.cpp.

{
  return is_superclass_of(target, source);
}

unload()

void dunedaq::Configuration::unload

(

)

Unload database.

The database should be previously loaded. The method destroys all user objects from cache (i.e. created via conffwk and template get methods) and frees all DB resources allocated by the implementation plug-in.

Exceptions

dunedaq::conffwk::Generic

in case of an error

Definition at line 355 of file Configuration.cpp.

{
  if (m_impl == nullptr)
    throw dunedaq::conffwk::Generic(ERS_HERE, "nothing to unload");
 
  std::lock_guard<std::mutex> scoped_lock1(m_tmpl_mutex); // always lock template objects mutex first
  std::lock_guard<std::mutex> scoped_lock2(m_impl_mutex);
 
  // call conffwk actions if any
  {
    std::lock_guard<std::mutex> scoped_lock(m_actn_mutex);
    for (auto& i : m_actions) {
      i->unload();
    }
  }
 
  // for (auto& i : m_cache_map) {
  //   delete i.second;
  // }
 
  // m_cache_map.clear();
  m_registry.clear();
 
  {
    std::lock_guard<std::mutex> scoped_lock3(m_else_mutex);
 
    for (auto& cb : m_callbacks)
      delete cb;
 
    for (auto& cb : m_pre_callbacks)
      delete cb;
 
    m_callbacks.clear();
    m_pre_callbacks.clear();
 
    m_impl->unsubscribe();
 
    for (auto& l : m_convert_map) {
      for (auto& a : *l.second)
        delete a;
 
      delete l.second;
    }
 
    m_convert_map.clear();
  }
 
  p_superclasses.clear();
 
  for (auto& j : p_direct_classes_desc_cache)
    delete j.second;
 
  for (auto& j : p_all_classes_desc_cache)
    delete j.second;
 
  p_direct_classes_desc_cache.clear();
  p_all_classes_desc_cache.clear();
 
  m_impl->close_db();
}

unread_all_objects()

void dunedaq::Configuration::unread_all_objects ( bool unread_implementation_objs = false )

noexcept

Unread all template (i.e. set their state as uninitialized) and implementation objects (i.e. clear their cache).

Unread template objects result changing their state to uninitialized. They will be re-initialized, when accessed by user code. This feature is used by attribute converter methods using unread_all_objects().

Unread implementation objects result removing any information from implementation cache, e.g. clear any object attributes data read from server. One may use the unread_all_objects() to re-read database after reload.

Parameters

unread_implementation_objs

if true, clear implementation objects; otherwise only template objects are unread and the implementation conffwk objects are still valid.

Definition at line 595 of file Configuration.cpp.

{
  if (unread_implementation_objs)
    unread_implementation_objects(dunedaq::conffwk::Unknown);
 
  unread_template_objects();
}

unread_implementation_objects()

void dunedaq::conffwk::Configuration::unread_implementation_objects ( dunedaq::conffwk::ObjectState state )

inlinenoexcept

Unread implementation objects (i.e. clear their cache).

This results removing any information from implementation cache, e.g. clear any object attributes data read from server.

Parameters

state

set state of implementation objects after unread; is set to "Unknown" after abort()

Definition at line 527 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_impl_mutex);
    _unread_implementation_objects(state);
  }

unread_template_objects()

void dunedaq::conffwk::Configuration::unread_template_objects ( )

inlinenoexcept

Unread all template (i.e. set their state as uninitialized) objects.

Unread template objects result changing their state to uninitialized. They will be re-initialized, when accessed by user code. This feature is used by attribute converter methods using unread_all_objects().

Definition at line 512 of file Configuration.hpp.

  {
    std::lock_guard<std::mutex> scoped_lock(m_tmpl_mutex);
    _unread_template_objects();
  }

unsubscribe()

void dunedaq::Configuration::unsubscribe

(

CallbackId

cb_handler = 0

)

Remove callback function.

Remove callback function previously added by the subscribe() methods. If the parameter is a non-null value, it must be equal to id returned by the add_callback() method. Otherwise the method stops all subscription.

Exceptions

dunedaq::conffwk::Generic

in case of an error (e.g. bad ID, plugin-specific problems)

Definition at line 1224 of file Configuration.cpp.

{
  std::lock_guard<std::mutex> scoped_lock(m_else_mutex);
 
  if (id) {
    CallbackSet::iterator i = m_callbacks.find(id);
    PreCallbackSet::iterator j = m_pre_callbacks.find(reinterpret_cast<CallbackPreSubscription*>(id));
 
    if (i != m_callbacks.end()) {
      delete id;
      m_callbacks.erase(i);
    } else if (j != m_pre_callbacks.end()) {
      delete reinterpret_cast<CallbackPreSubscription*>(id);
      m_pre_callbacks.erase(j);
    } else {
      std::ostringstream text;
      text << "unsubscription failed for CallbackId = " << (void*)id << " (no such callback id found)";
      throw(dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str()));
    }
  } else {
    for (auto& i : m_callbacks)
      delete i;
 
    for (auto& i : m_pre_callbacks)
      delete i;
 
    m_callbacks.clear();
    m_pre_callbacks.clear();
  }
 
  try {
    reset_subscription();
  } catch (dunedaq::conffwk::Generic& ex) {
    throw dunedaq::conffwk::Generic(ERS_HERE, "unsubscription failed", ex);
  }
}

update()

template<class T>

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

noexcept

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 300 of file Configuration.hxx.

{
  // 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);
}

update_cache()

void dunedaq::Configuration::update_cache ( std::vector< ConfigurationChange * > & changes )

noexcept

System function invoked in case of modifications.

It is used by the database implementation. Update cache of template DB objects.

Definition at line 1370 of file Configuration.cpp.

{
  TLOG_DEBUG(3) << "*** Enter Configuration::update_cache() with changes:\n" << changes;
 
  // Remove deleted and update modified implementation objects first
  for (const auto& i : changes) {
    const std::string* class_name = &DalFactory::instance().get_known_class_name_ref(i->get_class_name());
 
    update_impl_objects(m_impl->m_impl_objects, *i, class_name);
 
    // delete/update implementation objects defined in superclasses
    conffwk::fmap<conffwk::fset>::const_iterator sc = p_superclasses.find(class_name);
 
    if (sc != p_superclasses.end())
      for (const auto& c : sc->second)
        update_impl_objects(m_impl->m_impl_objects, *i, c);
 
    // delete/update implementation objects defined in subclasses
    sc = p_subclasses.find(class_name);
 
    if (sc != p_subclasses.end())
      for (const auto& c : sc->second)
        update_impl_objects(m_impl->m_impl_objects, *i, c);
  }
 
  for (const auto& i : changes) {
 
    m_registry.update(i->get_class_name(), i->get_modified_objs(), i->get_removed_objs(), i->get_created_objs());
 
    // const std::string * class_name = &DalFactory::instance().get_known_class_name_ref(i->get_class_name()); // FIXME:
    // optimise with above
 
    // // invoke configuration update if there are template objects of given class
 
    //   {
    //     conffwk::fmap<CacheBase*>::iterator j = m_cache_map.find(class_name);
 
    //     if (j != m_cache_map.end())
    //       {
    //         TLOG_DEBUG(3) << " * call update on \'" << j->first << "\' template objects";
    //         j->second->m_functions.m_update_fn(*this, i);
    //       }
    //   }
 
    // // invoke configuration update if there are template objects in super-classes
 
    //   {
    //     conffwk::fmap<conffwk::fset>::const_iterator sc = p_superclasses.find(class_name);
 
    //     if (sc != p_superclasses.end())
    //       {
    //         for (const auto& c : sc->second)
    //           {
    //             conffwk::fmap<CacheBase*>::iterator j = m_cache_map.find(c);
 
    //             if (j != m_cache_map.end())
    //               {
    //                 TLOG_DEBUG(3) << " * call update on \'" << j->first << "\' template objects (as super-class of
    //                 \'" << *class_name << "\')"; j->second->m_functions.m_update_fn(*this, i);
    //               }
    //           }
    //       }
    //   }
 
    // // invoke configuration update if there are template objects in sub-classes
 
    //   {
    //     conffwk::fmap<conffwk::fset>::const_iterator sc = p_subclasses.find(class_name);
 
    //     if (sc != p_subclasses.end())
    //       {
    //         for (const auto& c : sc->second)
    //           {
    //             conffwk::fmap<CacheBase*>::iterator j = m_cache_map.find(c);
 
    //             if (j != m_cache_map.end())
    //               {
    //                 TLOG_DEBUG(3) << " * call update on \'" << j->first << "\' template objects (as sub-class of \'"
    //                 << *class_name << "\')"; j->second->m_functions.m_update_fn(*this, i);
    //               }
    //           }
    //       }
    //   }
  }
}

update_classes()

void dunedaq::Configuration::update_classes ( )

privatenoexcept

Definition at line 638 of file Configuration.cpp.

{
  m_impl->get_superclasses(p_superclasses);
  this->set_subclasses();
  this->set_class_domain_map();
  m_registry.update_class_maps();
}

update_impl_objects()

void dunedaq::Configuration::update_impl_objects ( conffwk::pmap< conffwk::map< ConfigObjectImpl * > * > & cache, ConfigurationChange & change, const std::string * class_name )

staticprivate

Definition at line 1307 of file Configuration.cpp.

{
  if (change.get_removed_objs().empty() == false) {
    conffwk::pmap<conffwk::map<ConfigObjectImpl*>*>::iterator i = cache.find(class_name);
 
    if (i != cache.end()) {
      for (auto& x : change.get_removed_objs()) {
        conffwk::map<ConfigObjectImpl*>::iterator j = i->second->find(x);
        if (j != i->second->end()) {
          TLOG_DEBUG(2) << "set implementation object " << x << '@' << *class_name << " [" << (void*)j->second
                        << "] deleted";
 
          std::lock_guard<std::mutex> scoped_lock(j->second->m_mutex);
          j->second->m_state = dunedaq::conffwk::Deleted;
          j->second->clear();
        }
      }
    }
  }
 
  if (change.get_created_objs().empty() == false) {
    conffwk::pmap<conffwk::map<ConfigObjectImpl*>*>::iterator i = cache.find(class_name);
 
    if (i != cache.end()) {
      for (auto& x : change.get_created_objs()) {
        conffwk::map<ConfigObjectImpl*>::iterator j = i->second->find(x);
        if (j != i->second->end()) {
          TLOG_DEBUG(2) << "re-set created implementation object " << x << '@' << *class_name << " ["
                        << (void*)j->second << ']';
 
          std::lock_guard<std::mutex> scoped_lock(j->second->m_mutex);
          j->second->reset(); // it does not matter what the state was, always reset
        }
      }
    }
  }
 
  if (change.get_modified_objs().empty() == false) {
    conffwk::pmap<conffwk::map<ConfigObjectImpl*>*>::iterator i = cache.find(class_name);
 
    if (i != cache.end()) {
      for (auto& x : change.get_modified_objs()) {
        conffwk::map<ConfigObjectImpl*>::iterator j = i->second->find(x);
        if (j != i->second->end()) {
          TLOG_DEBUG(2) << "clear implementation object " << x << '@' << *class_name << " [" << (void*)j->second << ']';
 
          std::lock_guard<std::mutex> scoped_lock(j->second->m_mutex);
 
          if (j->second->m_state != dunedaq::conffwk::Valid)
            j->second->reset();
          else
            j->second->clear();
        }
      }
    }
  }
}

Friends And Related Symbol Documentation

ConfigObject

friend class ConfigObject

friend

Definition at line 237 of file Configuration.hpp.

ConfigurationImpl

friend class ConfigurationImpl

friend

Definition at line 238 of file Configuration.hpp.

DalObject

DalObject

friend

Definition at line 236 of file Configuration.hpp.

DalRegistry

friend class DalRegistry

friend

Definition at line 241 of file Configuration.hpp.

Member Data Documentation

m_actions

std::list<ConfigAction*> dunedaq::conffwk::Configuration::m_actions

private

Definition at line 1697 of file Configuration.hpp.

m_actn_mutex

std::mutex dunedaq::conffwk::Configuration::m_actn_mutex

mutableprivate

Definition at line 1705 of file Configuration.hpp.

m_callbacks

CallbackSet dunedaq::conffwk::Configuration::m_callbacks

private

Definition at line 1682 of file Configuration.hpp.

m_convert_map

conffwk::map<std::list<AttributeConverterBase*>*> dunedaq::conffwk::Configuration::m_convert_map

private

Definition at line 1467 of file Configuration.hpp.

m_else_mutex

std::mutex dunedaq::conffwk::Configuration::m_else_mutex

mutableprivate

Definition at line 1706 of file Configuration.hpp.

m_impl

ConfigurationImpl* dunedaq::conffwk::Configuration::m_impl

private

Definition at line 1667 of file Configuration.hpp.

m_impl_mutex

std::mutex dunedaq::conffwk::Configuration::m_impl_mutex

mutableprivate

Definition at line 1703 of file Configuration.hpp.

m_impl_name

std::string dunedaq::conffwk::Configuration::m_impl_name

private

Definition at line 1669 of file Configuration.hpp.

m_impl_param

std::string dunedaq::conffwk::Configuration::m_impl_param

private

Definition at line 1670 of file Configuration.hpp.

m_impl_spec

std::string dunedaq::conffwk::Configuration::m_impl_spec

private

Definition at line 1668 of file Configuration.hpp.

m_pre_callbacks

PreCallbackSet dunedaq::conffwk::Configuration::m_pre_callbacks

private

Definition at line 1683 of file Configuration.hpp.

m_registry

DalRegistry dunedaq::conffwk::Configuration::m_registry

private

Definition at line 1701 of file Configuration.hpp.

m_shlib_h

void* dunedaq::conffwk::Configuration::m_shlib_h

private

Definition at line 1672 of file Configuration.hpp.

m_tmpl_mutex

std::mutex dunedaq::conffwk::Configuration::m_tmpl_mutex

mutableprivate

Definition at line 1704 of file Configuration.hpp.

p_all_classes_desc_cache

conffwk::map<dunedaq::conffwk::class_t*> dunedaq::conffwk::Configuration::p_all_classes_desc_cache

private

Definition at line 1314 of file Configuration.hpp.

p_class_domain_map

conffwk::fmap<uint> dunedaq::conffwk::Configuration::p_class_domain_map

private

Definition at line 1445 of file Configuration.hpp.

p_direct_classes_desc_cache

conffwk::map<dunedaq::conffwk::class_t*> dunedaq::conffwk::Configuration::p_direct_classes_desc_cache

private

Definition at line 1313 of file Configuration.hpp.

p_number_of_cache_hits

std::atomic<uint_least64_t> dunedaq::conffwk::Configuration::p_number_of_cache_hits

private

Definition at line 1438 of file Configuration.hpp.

p_number_of_template_object_created

std::atomic<uint_least64_t> dunedaq::conffwk::Configuration::p_number_of_template_object_created

private

Definition at line 1439 of file Configuration.hpp.

p_number_of_template_object_read

std::atomic<uint_least64_t> dunedaq::conffwk::Configuration::p_number_of_template_object_read

private

Definition at line 1440 of file Configuration.hpp.

p_subclasses

conffwk::fmap<conffwk::fset> dunedaq::conffwk::Configuration::p_subclasses

private

Definition at line 1444 of file Configuration.hpp.

p_superclasses

conffwk::fmap<conffwk::fset> dunedaq::conffwk::Configuration::p_superclasses

private

Definition at line 1443 of file Configuration.hpp.

---

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

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