gtool.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: yes (from src/graphtool/gtool.cpp to apps/graphtool/gtool.cpp).
 
/************************************************************
 * gtool.cpp
 *
 *  Created on: Jun 10, 2016
 *      Author: Leonidas Georgopoulos
 ************************************************************/
 
#include "dbe/gtool.hpp"
#include "dbe/confaccessor.hpp"
#include "dbe/config_api.hpp"
#include "dbe/config_api_info.hpp"
#include "dbe/config_reference.hpp"
#include "dbe/graphtool.hpp"
#include "dbe/messenger.hpp"
 
#include <QFileInfo>
 
#include <boost/graph/graphviz.hpp>
 
#include <algorithm>
#include <string>
#include <vector>
 
namespace dbe {
namespace tool {
namespace graph {
 
//------------------------------------------------------------------------------------------
gtool::gtool(std::string const& rl, dbinfo dbtype)
  : this_src(rl)
{
  QFileInfo DatabaseFile(QString::fromStdString(rl));
 
  if (DatabaseFile.exists()) {
    QString path_to_database = QString(DatabaseFile.absoluteFilePath());
    {
      confaccessor::setdbinfo(path_to_database, dbtype);
      INFO("Database location set", "Program execution control success");
 
      if (confaccessor::load()) {
        INFO("Database initialized", "User request");
      } else {
        ERROR("Could not load database", "OKS error ", " Actions : check environment variables e.g. DUNEDAQ_DB_PATH");
        throw std::string("Could not load database");
      }
    }
  } else {
    ERROR("Cannot open database", "File error", "for file", rl);
  }
}
 
gtool::t_graph const&
gtool::getgraph() const
{
  return this_graph;
}
 
void
gtool::load_all()
{
  INFO("Start load objects into internal cache", "Program execution control");
 
  std::vector<std::string> all_classes = { config::api::info::onclass::allnames<std::vector<std::string>>() };
 
  for (auto const& x : all_classes) {
    load_all_class_objects(x);
  }
 
  INFO("All objects loaded into internal cache",
       "Program execution control success",
       "#objects:",
       std::to_string(this_all_objects.size()));
}
 
void
gtool::load_all_class_objects(std::string const& cname)
{
  std::vector<dbe::tref> all_objects = config::api::info::onclass::objects<false>(cname, false);
 
  INFO("Class to load: ", "Program execution control", cname);
 
  for (dbe::tref const& x : all_objects) {
    this_all_objects.push_back(x);
  }
 
  INFO("Class load success: ", "Program execution control", cname, "#objects", std::to_string(all_objects.size()));
}
 
void
gtool::create_graph()
{
  INFO("Database graph generation initiated", "Program execution control");
  already_processed.clear();
 
  for (auto const& x : this_all_objects) {
    add_object_and_friends(this_graph, x, already_processed);
  }
 
  INFO("Graph generation completed successfully", "Program execution control success");
}
 
gtool::t_vertex
gtool::add_object(gtool::t_graph& g, tref const& x, bool uniqueness)
{
  vertex_label xl{ x.UID(), x.class_name(), x.full_name() };
 
  if (not uniqueness) {
    // Multiple vertices with the same properties can be added to this graph
    return boost::add_vertex(xl, g);
  } else {
    bool result;
    boost::graph_traits<t_graph>::vertex_iterator viter;
    std::tie(result, viter) = lookup(g, xl);
 
    if (result) {
      return *viter;
    } else {
      return boost::add_vertex(xl, g);
    }
  }
}
 
gtool::t_vertex
gtool::add_object(gtool::t_graph& g, tref const& x, t_registry& registry)
{
  t_registry::iterator vat = registry.find(x.full_name());
 
  if (std::end(registry) == vat) {
    FULLDEBUG("Adding object", "Program execution control", x.full_name());
    // not in the registry implies it is not in the graph , i.e. its user responsibility
    t_registry::iterator v;
    std::tie(v, std::ignore) = registry.emplace(x.full_name(), add_object(g, x, false));
    return v->second;
  } else {
    return vat->second;
  }
}
 
gtool::t_vertex
gtool::add_object_and_friends(t_graph& g, tref const& o, t_registry& registry)
{
  DEBUG("Processing object", "Program execution control", o.full_name());
  t_vertex ov = add_object(g, o, registry);
 
  std::vector<tref> friends{ config::api::graph::linked::by::object<tref>(o) }; // get all neighbors
  DEBUG(
    "Processing object", "Program execution control", o.full_name(), " # friends: ", std::to_string(friends.size()));
 
  for (tref const& x : friends) {
    t_vertex xv = add_object(g, x, registry);
    boost::add_edge(ov, xv, g);
    FULLDEBUG("Add edge ", "Program excecution control", o.full_name(), "->", x.full_name());
  }
 
  return ov;
}
 
gtool::t_lookup_ret
gtool::lookup(t_graph const& g, vertex_label const& l)
{
  auto const& vertices = boost::vertices(g);
 
  for (auto v = vertices.first; v != vertices.second; ++v) {
    if (l.label == boost::get(&vertex_label::label, g, *v)) {
      return t_lookup_ret(true, v);
    }
  }
 
  return t_lookup_ret(false, vertices.second);
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
writegraph::writegraph(std::string const& s)
  : this_dest(s)
{
}
 
int
writegraph::operator()(gtool const& x) const
{
  INFO("Saving result", "Program execution control", this_dest);
  write(x.getgraph());
  INFO("Result sent to output", "Program execution control success", this_dest);
  return EXIT_SUCCESS;
}
 
void
writegraph::write(gtool::t_graph const& g) const
{
  graph::write(g, this_dest);
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
void
write(gtool::t_graph const& g, std::string const& ofn)
{
  if (ofn.empty()) {
    write_to_cout(g);
  } else {
    write_to_file(g, ofn);
  }
}
 
void
write_to_cout(gtool::t_graph const& g)
{
  INFO("Sending output to stdout", "Program execution control")
  boost::write_graphviz(std::cout, g, boost::make_label_writer(boost::get(&gtool::vertex_label::label, g)));
}
 
void
write_to_file(gtool::t_graph const& g, std::string const& ofn)
{
  std::ofstream of;
  of.open(ofn);
 
  if (of.is_open()) {
    INFO("Sending output to file", "Program execution control", "File name:", ofn);
    boost::write_graphviz(of, g, boost::make_label_writer(boost::get(&gtool::vertex_label::label, g)));
 
    of.close();
 
    if (of.fail()) {
      ERROR("Could not close file", "Program execution control", "File name:", ofn);
    } else {
      NOTE("Output written to file", "Program execution control success", "File name:", ofn);
    }
  } else {
    ERROR("Output could not be written file", "Stream could not be opened", "File name:", ofn);
    write_to_cout(g);
  }
}
//------------------------------------------------------------------------------------------
 
} /* namespace graph */
} /* namespace tool */
} /* namespace dbe */