config_api_graph.cpp

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: no.
 
/*
 * config_api_graph.cpp
 *
 *  Created on: Apr 20, 2016
 *      Author: Leonidas Georgopoulos
 */
 
#include "dbe/config_api_graph.hpp"
#include "dbe/config_api_info.hpp"
#include "dbe/confobject_desc.hpp"
#include "dbe/dbcontroller.hpp"
#include "dbe/messenger.hpp"
 
#include "conffwk/Schema.hpp"
 
#include <algorithm>
 
using namespace dunedaq::conffwk;
 
//------------------------------------------------------------------------------------------
//                                      DBE::CONFIG::API::GRAPH NAMESPACE
//------------------------------------------------------------------------------------------
namespace dbe
{
namespace config
{
namespace api
{
namespace graph
{
 
 
//------------------------------------------------------------------------------------------
namespace linked
{
namespace through
{
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
/*
 * Objects referenced by the given object through a specific attribute
 */
template<>
tref attribute<tref> ( tref object, dunedaq::conffwk::attribute_t const & attr )
{
  return object.get<tref> ( attr.p_name );
}
 
template<>
std::vector<tref> attribute<std::vector<tref>> (
                                              tref item, dunedaq::conffwk::attribute_t const & attr )
{
  if ( attr.p_type == dunedaq::conffwk::class_type )
  {
    if ( attr.p_is_multi_value )
    {
      std::vector<tref> adj;
      item.get ( attr.p_name, adj );
      return adj;
    }
    else if ( attr.p_is_not_null )
    {
      try
      {
        return
        { attribute<tref> ( item, attr ) };
      }
      catch ( daq::dbe::config_object_retrieval_result_is_null const & e )
      {
        if ( attr.p_is_not_null )
        {
          WARN (
            "Query returned null value for an attr that has p_is_not_null set true",
            "Program parsing data validation failure", item.full_name(),
            " for attribute ", attr.p_name );
        }
        else
        {
          DEBUG ( "Query returned null value", "Program parsing data validation" );
        }
      }
    }
  }
 
  return
    {};
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
/*
 * Objects referenced by the given object through a specific relation
 */
template<>
tref relation<tref> ( tref object, dunedaq::conffwk::relationship_t const & r )
{
  return object.get<tref> ( r.p_name );
}
 
template<>
std::vector<tref> relation<std::vector<tref>> (
                                             tref item, dunedaq::conffwk::relationship_t const & r )
{
  if ( dbe::config::api::info::relation::is_simple ( r ) )
  {
    try
    {
      return
      { through::relation<tref> ( item, r ) };
    }
    catch ( daq::dbe::config_object_retrieval_result_is_null const & e )
    {
      return
        {};
    }
  }
  else
  {
    std::vector<tref> adjacent;
    item.get ( r.p_name, adjacent );
    return adjacent;
  }
}
 
template<>
QStringList relation<QStringList> (
  tref item, dunedaq::conffwk::relationship_t const & r )
{
  QStringList result;
  std::vector<tref> adjacent = relation<std::vector<tref>> ( item, r );
 
  for ( auto const & x : adjacent )
  {
    result.push_back ( x.UID().c_str() );
  }
 
  return result;
}
 
template<>
std::vector<dbe::config_object_description<std::string>> relation <
                                                      std::vector<dbe::config_object_description<std::string> > > (
                                                        tref object, dunedaq::conffwk::relationship_t const & relation )
{
  std::vector<dbe::config_object_description<std::string>> result;
 
  std::vector<tref> adjacent = linked::through::relation<std::vector<tref>> ( object,
                                                                              relation );
 
  for ( auto const & x : adjacent )
  {
    result.push_back ( x );
  }
 
  return result;
}
 
//------------------------------------------------------------------------------------------
} // end namespace through
} // end namespace link  
 
//------------------------------------------------------------------------------------------
template<typename T>
inline T direct::linked ( ConfigObject & input,
                          dunedaq::conffwk::relationship_t const & relation )
{
  T value;
  input.get ( relation.p_name, value );
  return value;
}
 
template
ConfigObject direct::linked<ConfigObject> (
  ConfigObject &, dunedaq::conffwk::relationship_t const & );
 
template
std::vector<ConfigObject>
direct::linked<std::vector<ConfigObject>> (
  ConfigObject &, dunedaq::conffwk::relationship_t const & );
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
/*
 * Retrieve objects referenced by an object through any of its relations
 */
template<typename T>
std::vector<T> linked::through::relations ( inner::configobject::tref const & o )
{
  dunedaq::conffwk::class_t classdef
  { info::onclass::definition ( o.class_name(), false ) };
 
  std::vector<T> voisins;
 
  for ( dunedaq::conffwk::relationship_t const & r : classdef.p_relationships )
  {
    std::vector<T> a = relation<std::vector<T>> ( o, r );
    voisins.insert ( voisins.end(), a.begin(), a.end() );
  }
 
  voisins.erase ( std::unique ( std::begin ( voisins ), std::end ( voisins ) ),
                  std::end ( voisins ) );
  return voisins;
}
template std::vector<tref> linked::through::relations<tref> ( tref const & );
 
/*
 * Retrieve objects linked by an object through any of its attributes
 */
template<typename T>
std::vector<T> linked::through::attributes ( inner::configobject::tref const & o )
{
  dunedaq::conffwk::class_t classdef
  { info::onclass::definition ( o.class_name(), true ) };
 
  std::vector<T> voisins;
 
  for ( dunedaq::conffwk::attribute_t const & attr : classdef.p_attributes )
  {
    std::vector<tref> a = attribute<std::vector<T>> ( o, attr );
    voisins.insert ( voisins.end(), a.begin(), a.end() );
  }
 
  voisins.erase ( std::unique ( std::begin ( voisins ), std::end ( voisins ) ),
                  std::end ( voisins ) );
  return voisins;
}
template std::vector<tref> linked::through::attributes<tref> ( tref const & );
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
/*
 * Retrieve links by operating directly on a ConfigObject
 */
template<typename T>
inline T direct::linked ( ConfigObject & input, dunedaq::conffwk::attribute_t const & relation )
{
  T value;
  input.get ( relation.p_name, value );
  return value;
}
 
template<>
inline QStringList direct::linked<QStringList> (
  ConfigObject & input, dunedaq::conffwk::relationship_t const & relation )
{
  QStringList result;
  std::vector<ConfigObject> adjacent;
 
  if ( info::relation::is_simple ( relation ) )
  {
    adjacent =
    { direct::linked<ConfigObject> ( input, relation ) };
  }
  else
  {
    adjacent = direct::linked<std::vector<ConfigObject>> ( input, relation );
  }
 
  for ( auto const & x : adjacent )
  {
    result.push_back ( x.UID().c_str() );
  }
 
  return result;
}
 
template
ConfigObject direct::linked<ConfigObject> ( ConfigObject &,
                                            dunedaq::conffwk::attribute_t const & );
template
std::vector<ConfigObject>
direct::linked<std::vector<ConfigObject>> ( ConfigObject &,
                                            dunedaq::conffwk::attribute_t const & );
template
QStringList direct::linked<QStringList> (
  ConfigObject &, dunedaq::conffwk::relationship_t const & );
//------------------------------------------------------------------------------------------
 
 
template
tref linked::through::attribute<tref> (
  inner::configobject::tref, dunedaq::conffwk::attribute_t const & );
template
std::vector<tref> linked::through::attribute<std::vector<tref>> (
                                                               inner::configobject::tref, dunedaq::conffwk::attribute_t const & );
template
tref linked::through::relation<tref> ( tref, dunedaq::conffwk::relationship_t const & );
template
std::vector<tref>
linked::through::relation<std::vector<tref>> ( tref, dunedaq::conffwk::relationship_t const & );
template
QStringList linked::through::relation<QStringList> ( tref,
                                                     dunedaq::conffwk::relationship_t const & );
template
std::vector<dbe::config_object_description<std::string>> linked::through::relation <
std::vector<dbe::config_object_description<std::string> > > (
  dbe::inner::configobject::tref, dunedaq::conffwk::relationship_t const & );
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
namespace linked
{
namespace by
{
/*
 * Get objects that are linked by a given object
 */
template<typename T> std::vector<T> object ( inner::configobject::tref const & o )
{
  std::vector<T> links = through::attributes<T> ( o );
  std::vector<T> rlinks = through::relations<T> ( o );
 
  if ( not rlinks.empty() )
  {
    links.insert ( links.end(), rlinks.begin(), rlinks.end() );
  }
 
  links.erase ( std::unique ( links.begin(), links.end() ), links.end() );
 
  return links;
}
 
} // end namespace by
} // end namespace link
template
std::vector<inner::configobject::tref>
linked::by::object<inner::configobject::tref> ( inner::configobject::tref const & );
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
namespace linked
{
namespace to
{
 
/*
 * Get objects which link to a given object
 */
template<>
std::vector<inner::configobject::tref> object<inner::configobject::tref> (
  inner::configobject::tref const & o )
{
  // Use with caution ... takes for ever to complete due to the underlying
  // ConfigObject implementation
  return o.referenced_by ( "*", false );
}
 
} // end namespace to
} // end namespace link
template
std::vector<inner::configobject::tref>
linked::to::object<inner::configobject::tref> ( inner::configobject::tref const & );
//------------------------------------------------------------------------------------------
}
}
}
}
//------------------------------------------------------------------------------------------