config_reference.hpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: yes (from dbe/config_reference.hpp to include/dbe/config_reference.hpp).
 
/*
 * config_reference.hpp
 *
 *  Created on: Feb 1, 2016
 *      Author: Leonidas Georgopoulos
 */
 
#ifndef DBE_CONFIG_REFERENCE_HPP_
#define DBE_CONFIG_REFERENCE_HPP_
 
#include "dbe/Exceptions.hpp"
#include "dbe/config_object_key.hpp"
 
#include "conffwk/ConfigObject.hpp"
 
#include <memory>
#include <vector>
 
#ifndef DONOT_THROW_ON_NULL_CONFIGOBJECT_REFERENCE
#define DEBUG_THROW_ON_NULL_CONFIGOBJECT_REFERENCE                                                                     \
  if (check_null and rval.is_deleted())                                                                                \
    throw daq::dbe::null_config_reference_access(ERS_HERE);
#else
#define DEBUG_THROW_ON_NULL_CONFIGOBJECT_REFERENCE
#endif
 
namespace dbe {
namespace inner {
class dbcontroller;
 
namespace configobject {
 
//------------------------------------------------------------------------------------------
class oref;

class wref
{
  dunedaq::conffwk::ConfigObject ref;
  wref(dunedaq::conffwk::ConfigObject const& o)
    : ref(o)
  {
  }
 
  wref(wref const&) = delete;
  wref operator=(wref const&) = delete;
 
  friend class oref;
};
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
struct refhasher;
 
class tref;
class vref;
template<typename>
class gref;
template<typename>
class aref;
class oref
{
  friend class tref;
  friend class vref;
  friend struct refhasher;
  template<typename>
  friend class aref;
  template<typename>
  friend class gref;
  friend class dbe::inner::dbcontroller;
  friend bool operator==(dbe::cokey const& left, dbe::cokey const& right);
 
  wref ref;
  std::string this_last_full_name;

  oref(dunedaq::conffwk::ConfigObject const& o) noexcept(true)
    : ref{ o }
    , this_last_full_name(o.full_name())
  {
  }
 
  std::string full_name() const { return this_last_full_name; }
 
  void rename(std::string const& newname)
  {
    ref.ref.rename(newname);
    this_last_full_name = newname;
  }

  explicit operator dunedaq::conffwk::ConfigObject&() noexcept { return ref.ref; }
 
  explicit operator dunedaq::conffwk::ConfigObject const&() const noexcept { return ref.ref; }
 
  // non-copyable
  oref(oref const&) = delete;
  oref operator=(oref const&) = delete;
 
public:
  operator dbe::cokey() const { return { ref.ref.UID(), ref.ref.class_name() }; }
};
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename T>
class ref_interface;
 
template<typename T, typename U>
class authorized_getter
{
private:
  ref_interface<T> const* that;
 
public:
  authorized_getter(ref_interface<T> const* caller)
    : that(caller)
  {
  }
 
  U operator()(std::string const& key);
};
 
template<typename T>
class ref_interface
{
private:
  explicit operator dunedaq::conffwk::ConfigObject&() noexcept { return static_cast<T*>(this)->ref(); }
 
  explicit operator dunedaq::conffwk::ConfigObject&() const noexcept { return static_cast<T const*>(this)->ref(); }
 
protected:
  template<typename U>
  U getdirect(std::string const& key) const
  {
    U value;
    try {
      static_cast<dunedaq::conffwk::ConfigObject&>(*const_cast<ref_interface<T>*>(this)).get(key, value);
    } catch (dunedaq::conffwk::Exception const& e) {
      // TODO handle retrieval errors here
    }
    return value;
  }
 
  template<typename X, typename U>
  friend class authorized_getter;
 
public:
  bool is_null() const
  {
    return static_cast<dunedaq::conffwk::ConfigObject&>(static_cast<T const*>(this)->ref(false)).is_deleted();
  }
 
  std::string UID() const { return static_cast<dunedaq::conffwk::ConfigObject&>(*this).UID(); }
 
  std::string class_name() const { return static_cast<dunedaq::conffwk::ConfigObject&>(*this).class_name(); }
 
  std::string full_name() const { return static_cast<dunedaq::conffwk::ConfigObject&>(*this).full_name(); }
 
  std::string contained_in() const { return static_cast<dunedaq::conffwk::ConfigObject&>(*this).contained_in(); }

  template<typename U>
  U get(std::string const& key)
  {
    authorized_getter<T, U> guard(this);
    return guard(key);
  }

  template<typename U>
  void get(std::string const& key, U& val)
  {
    val = get<U>(key);
  }

  std::vector<T> referenced_by(std::string const& name = "*", bool check_composite_only = true) const;
 
  void set_obj_null(std::string const& name, bool is_simple, bool skip_non_null_check = false)
  {
    if (is_simple) {
      static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_obj(name, nullptr, skip_non_null_check);
    } else {
      static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_objs(name, {}, skip_non_null_check);
    }
  }
 
  void set_obj(std::string const& name, T const& other, bool skip_non_null_check = false)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_obj(
      name, &static_cast<dunedaq::conffwk::ConfigObject&>(other), skip_non_null_check);
  }
 
  void set_objs(std::string const& name, std::vector<T> const& others, bool skip_non_null_check = false)
  {
    std::vector<dunedaq::conffwk::ConfigObject const*> configobjects;
 
    std::transform(std::begin(others), std::end(others), std::back_inserter(configobjects), [](T const& aref) {
      return &static_cast<dunedaq::conffwk::ConfigObject const&>(aref);
    });
 
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_objs(name, configobjects, skip_non_null_check);
  }
 
  template<typename U>
  void set_by_val(std::string const& name, U val)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_by_val(name, val);
  }
 
  template<typename U>
  void set_by_ref(std::string const& name, U& val)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_by_ref(name, val);
  }
 
  void set_enum(std::string const& name, std::string const& val)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_enum(name, val);
  }
 
  void set_class(std::string const& name, std::string const& val)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_class(name, val);
  }
 
  void set_date(std::string const& name, std::string const& val)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_date(name, val);
  }
 
  void set_time(std::string const& name, std::string const& val)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_time(name, val);
  }
 
  void set_enum(std::string const& name, const std::vector<std::string>& value)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_enum(name, value);
  }
 
  void set_class(std::string const& name, const std::vector<std::string>& value)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_class(name, value);
  }
 
  void set_date(std::string const& name, const std::vector<std::string>& value)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_date(name, value);
  }
 
  void set_time(std::string const& name, const std::vector<std::string>& value)
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).set_time(name, value);
  }
 
  void move(std::string const& at) { static_cast<dunedaq::conffwk::ConfigObject&>(*this).move(at); }

 
  void print_ref(
    std::ostream& s,                       
    dunedaq::conffwk::Configuration& conf, 
    const std::string& prefix = "",        
    bool show_contained_in = false         
  ) const
  {
    static_cast<dunedaq::conffwk::ConfigObject&>(*this).print_ref(s, conf, prefix, show_contained_in);
  }
 
  friend std::ostream& operator<<(std::ostream& os, dbe::inner::configobject::tref const& atref);
 
  friend class dbe::inner::configobject::tref;
  friend class dbe::inner::configobject::vref;
  friend class dbe::inner::configobject::aref<T>;
};
//------------------------------------------------------------------------------------------

template<typename T>
class authorized_getter<T, configobject::tref>
{
private:
  ref_interface<T> const* that;
 
public:
  authorized_getter(ref_interface<T> const* caller)
    : that(caller)
  {
  }
 
  configobject::tref operator()(std::string const& key);
};

template<typename T>
class authorized_getter<T, std::vector<configobject::tref>>
{
private:
  ref_interface<T> const* that;
 
public:
  authorized_getter(ref_interface<T> const* caller)
    : that(caller)
  {
  }
 
  std::vector<configobject::tref> operator()(std::string const& key);
};

template<typename T>
class authorized_getter<T, dunedaq::conffwk::ConfigObject>
{
private:
  ref_interface<T> const* that;
 
public:
  authorized_getter(ref_interface<T> const* caller)
    : that(caller)
  {
  }
 
  dunedaq::conffwk::ConfigObject operator()(std::string const& key) = delete;
};

template<typename T>
class authorized_getter<T, std::vector<dunedaq::conffwk::ConfigObject>>
{
private:
  ref_interface<T> const* that;
 
public:
  authorized_getter(ref_interface<T> const* caller)
    : that(caller)
  {
  }
 
  std::vector<dunedaq::conffwk::ConfigObject> operator()(std::string const& key) = delete;
};
 
template<typename T, typename U>
U
authorized_getter<T, U>::operator()(std::string const& key)
{
  return this->that->template getdirect<U>(key);
}
 
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
struct refhasher
{
  size_t operator()(dbe::cokey const& o) const { return std::hash<std::string>()(o.this_class + o.this_name); }
};
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
class tref : public ref_interface<tref>
{
private:
  std::shared_ptr<oref> refered;
 
  dunedaq::conffwk::ConfigObject& ref(bool check_null = true) const
  {
    dunedaq::conffwk::ConfigObject& rval = static_cast<dunedaq::conffwk::ConfigObject&>(*refered.get());
    DEBUG_THROW_ON_NULL_CONFIGOBJECT_REFERENCE
    return rval;
  }
 
  tref(std::shared_ptr<oref> other)
    : refered(other)
  {
  }
 
  friend class ref_interface<tref>;
  friend class dbe::inner::dbcontroller;
};
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
class vref : public ref_interface<vref>
{
private:
  std::weak_ptr<oref> refered;
 
  dunedaq::conffwk::ConfigObject& ref(bool check_null = false) const
  {
    std::shared_ptr<oref> return_val =
      refered.expired() ? std::shared_ptr<oref>(new oref(dunedaq::conffwk::ConfigObject())) : refered.lock();
    dunedaq::conffwk::ConfigObject& rval = static_cast<dunedaq::conffwk::ConfigObject&>(*return_val);
    DEBUG_THROW_ON_NULL_CONFIGOBJECT_REFERENCE
    return rval;
  }
 
  vref(std::weak_ptr<oref> other)
    : refered(other)
  {
  }
 
  friend class ref_interface<vref>;
  friend class dbe::inner::dbcontroller;
};
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename T>
inline std::ostream&
operator<<(std::ostream& os, ref_interface<T> const& atref)
{
  return os << static_cast<T const&>(atref).ref();
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename T>
inline bool
operator==(ref_interface<T> const& l, ref_interface<T> const& r)
{
  return l.UID() == r.UID() and l.class_name() == r.class_name();
}
//------------------------------------------------------------------------------------------
 
}
}
}
 
#endif /* DBE_CONFIG_REFERENCE_HPP_ */