ConfigObject.cpp

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS config source for the DUNE DAQ project.
// Fork baseline commit: 67a24e731 (2022-10-27).
// Renamed since fork: no.
//
 
#include <vector>
#include <iostream>
 
#include "conffwk/Configuration.hpp"
#include "conffwk/ConfigurationImpl.hpp"
#include "conffwk/ConfigObject.hpp"
#include "conffwk/ConfigObjectImpl.hpp"
#include "conffwk/Schema.hpp"
 
namespace dunedaq {
namespace conffwk {
 
ConfigObject::ConfigObject() noexcept :
  m_impl(nullptr)
{
}
 
ConfigObject::ConfigObject(const ConfigObject& other) noexcept :
  m_impl(other.m_impl)
{
}
 
ConfigObject::ConfigObject(ConfigObjectImpl *impl) noexcept :
  m_impl(impl)
{
}
 
ConfigObject::~ConfigObject() noexcept
{
}
 
ConfigObject&
ConfigObject::operator=(const ConfigObject& other) noexcept
{
  if(this != &other) {
    m_impl = other.m_impl;
  }
 
  return *this;
}
 
ConfigObject&
ConfigObject::operator=(ConfigObjectImpl *impl) noexcept
{
  if(m_impl != impl) {
    m_impl = impl;
  }
 
  return *this;
}
 
bool
ConfigObject::operator==(const ConfigObject& other) const noexcept
{
  if(this == &other || m_impl == other.m_impl) return true;  // the objects or implementations are the same
  if(!m_impl || !other.m_impl) return false;                 // only one of objects has no implementation
  return ((UID() == other.UID()) && (class_name() == other.class_name()));
}
 
void
ConfigObject::print_ptr(std::ostream& s) const noexcept
{
  if(m_impl)
    {
      if(m_impl->is_deleted())
        {
          s << "(deleted object " << full_name() << ')';
        }
      else
        {
          s << full_name();
        }
    }
  else
    {
      s << "(null)";
    }
}
 
Configuration *
ConfigObject::get_configuration() const
{
  return m_impl->m_impl->m_conf;
}
 
void
ConfigObject::rename(const std::string& new_id)
{
  get_configuration()->rename_object(*this, new_id);
  action_on_object_update(get_configuration(), new_id);
}
 
void
ConfigObject::action_on_object_update(Configuration * db, const std::string& name)
{
  db->action_on_update(*this, name);
}
 
std::ostream&
operator<<(std::ostream& s, const ConfigObject * obj)
{
  obj->print_ptr(s);
  return s;
}
 
std::ostream&
operator<<(std::ostream& s, const ConfigObject & obj)
{
  obj.print_ptr(s);
  return s;
}
 
inline static void
print_sep(const char sep, std::ostream& s)
{
  if (sep)
    s << sep;
}
 
template<class T>
  void
  print_val(const T &val, std::ostream &s)
  {
    s << val;
  }
 
template<>
  void
  print_val<uint8_t>(const uint8_t &val, std::ostream &s)
  {
    s << static_cast<uint16_t>(val);
  }
 
template<>
  void
  print_val<int8_t>(const int8_t &val, std::ostream &s)
  {
    s << static_cast<int16_t>(val);
  }
 
template<class T>
  void
  print_value(const ConfigObject& const_obj, const std::string& name, const bool ismv, const char sep, std::ostream& s)
  {
    ConfigObject& obj = const_cast<ConfigObject&>(const_obj);
 
    try
      {
        if (ismv)
          {
            std::vector<T> value;
 
            obj.get(name, value);
 
            print_sep('(', s);
 
            for (unsigned int i = 0; i < value.size(); ++i)
              {
                if (i != 0)
                  s << ", ";
 
                print_sep(sep, s);
                print_val<T>(value[i],s);
                print_sep(sep, s);
              }
 
            print_sep(')', s);
          }
        else
          {
            T value;
 
            obj.get(name, value);
 
            print_sep(sep, s);
            print_val<T>(value,s);
            print_sep(sep, s);
          }
      }
    catch (ers::Issue & ex)
      {
        s << "[bad_object] (could not get value of \'" << name << "\' of object \'" << &obj << "\': " << ex << ')';
      }
  }
 
// workaround to avoid annoying warning about comparing this with nullptr
inline bool
is_null_obj(const ConfigObject * o)
{
  return (o == nullptr || o->is_null());
}
 
void
ConfigObject::print_ref(std::ostream& s, Configuration& conffwk, const std::string& prefix, bool show_contained_in) const noexcept
{
  static bool expand_aggregation = (getenv("TDAQ_CONFFWK_PRINT_EXPAND_AGGREGATIONS")); // FIXME tdaq-09-05-00 => add new parameter to conffwk and add fuse
 
  // check if it is not a reference to 0
  if (is_null_obj(this))
    {
      s << prefix << "(null)";
      return;
    }
 
  // print out object-id and class-name
  s
    << prefix << "Object:\n"
    << prefix << "  id: \'" << UID() << "\', class name: \'" << class_name() << "\'\n";
 
  if (show_contained_in)
    s << prefix << "  contained in: \'" << contained_in() << "\'\n";
 
  try
    {
      const dunedaq::conffwk::class_t& cd(conffwk.get_class_info(class_name()));
 
      // print attributes
      for (const auto& i : cd.p_attributes)
        {
          const std::string& aname(i.p_name);    // attribute name
          const bool ismv(i.p_is_multi_value);   // attribute is multi-value
 
          s << prefix << "  " << aname << ": ";
 
          switch (i.p_type)
            {
              case dunedaq::conffwk::string_type :
              case dunedaq::conffwk::enum_type :
              case dunedaq::conffwk::date_type :
              case dunedaq::conffwk::time_type :
              case dunedaq::conffwk::class_type :
                                             print_value<std::string>(*this, aname, ismv, '\"', s); break;
              case dunedaq::conffwk::bool_type:   print_value<bool>(*this, aname, ismv, 0, s);           break;
              case dunedaq::conffwk::u8_type:     print_value<uint8_t>(*this, aname, ismv, 0, s);        break;
              case dunedaq::conffwk::s8_type:     print_value<int8_t>(*this, aname, ismv, 0, s);         break;
              case dunedaq::conffwk::u16_type:    print_value<uint16_t>(*this, aname, ismv, 0, s);       break;
              case dunedaq::conffwk::s16_type:    print_value<int16_t>(*this, aname, ismv, 0, s);        break;
              case dunedaq::conffwk::u32_type:    print_value<uint32_t>(*this, aname, ismv, 0, s);       break;
              case dunedaq::conffwk::s32_type:    print_value<int32_t>(*this, aname, ismv, 0, s);        break;
              case dunedaq::conffwk::u64_type:    print_value<uint64_t>(*this, aname, ismv, 0, s);       break;
              case dunedaq::conffwk::s64_type:    print_value<int64_t>(*this, aname, ismv, 0, s);        break;
              case dunedaq::conffwk::float_type:  print_value<float>(*this, aname, ismv, 0, s);          break;
              case dunedaq::conffwk::double_type: print_value<double>(*this, aname, ismv, 0, s);         break;
              default:                       s << "*** bad type ***";
            }
 
          s << std::endl;
        }
 
      // print relationships
      for (const auto& i : cd.p_relationships)
        {
          s << prefix << "  " << i.p_name << ':';
          if (expand_aggregation == false || i.p_is_aggregation == false)
            {
              s << ' ';
              print_value<ConfigObject>(*this, i.p_name, (i.p_cardinality == dunedaq::conffwk::zero_or_many) || (i.p_cardinality == dunedaq::conffwk::one_or_many), '\"', s);
              s << std::endl;
            }
          else
            {
              s << std::endl;
              std::string prefix2(prefix + "    ");
              ConfigObject& obj = const_cast<ConfigObject&>(*this);
              if ((i.p_cardinality == dunedaq::conffwk::zero_or_many) || (i.p_cardinality == dunedaq::conffwk::one_or_many))
                {
                  std::vector<ConfigObject> value;
                  obj.get(i.p_name, value);
                  if (value.empty())
                    s << prefix2 << "(null)\n";
                  else
                    for (const auto& x : value)
                      x.print_ref(s, conffwk, prefix2, show_contained_in);
                }
              else
                {
                  ConfigObject value;
                  obj.get(i.p_name, value);
                  if (value.is_null())
                    s << prefix2 << "(null)\n";
                  else
                    value.print_ref(s, conffwk, prefix2, show_contained_in);
                }
            }
        }
    }
  catch (dunedaq::conffwk::Exception& ex)
    {
      s << "cannot get schema description: caught dunedaq::conffwk::Exception exception" << std::endl;
      std::cerr << "ERROR: " << ex << std::endl;
    }
 
}
 
 
ConfigObject* 
ConfigObject::get_obj_pybind(const std::string& attrname) {
  
  ConfigObject* newobject = new ConfigObject;
 
  if (newobject) {
    this->get(attrname, *newobject);
 
    if (newobject->is_null()) {
      delete newobject;
      return nullptr;
    }
  } 
  
  return newobject;
}
 
} // namespace conffwk
} // namespace dunedaq