oks_report_equal_objects.cxx

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks_utils source for the DUNE DAQ project.
// Fork baseline commit: c2e7dfc7 (2022-03-30).
// Renamed since fork: yes (from src/bin/oks_report_equal_objects.cpp to apps/oks_report_equal_objects.cxx).
//

 
#include <iostream>
#include <sstream>
 
#include <map>
#include <set>
 
#include <boost/program_options.hpp>
 
#include "oks/attribute.hpp"
#include "oks/class.hpp"
#include "oks/kernel.hpp"
#include "oks/object.hpp"
#include "oks/relationship.hpp"
 
using namespace dunedaq;
using namespace dunedaq::oks;
 
struct SortObjById
{
  bool operator()(const OksObject* o1, const OksObject* o2) const { return o1->GetId() < o2->GetId(); }
};
 
typedef std::set<const OksObject*, SortObjById> ObjsSet;

 
static void
process_class(const OksClass* c, bool verbose)
{
  bool printed_class(false);
 
  if (verbose) {
    std::cout << "* processing class \'" << c->get_name() << "\'" << std::endl;
    printed_class = true;
  }
 
  const OksObject::Map* objects = c->objects();
  if (!objects || objects->empty()) {
    if (verbose) {
      std::cout << "  no objects" << std::endl;
    }
    return;
  }
 
  std::multimap<std::string, const OksObject*> vals;
 
  const std::list<OksAttribute*>* alist = c->all_attributes();
  const std::list<OksRelationship*>* rlist = c->all_relationships();
 
  OksDataInfo di(0, (const OksAttribute*)(0));
 
  for (OksObject::Map::const_iterator i = objects->begin(); i != objects->end(); ++i) {
    const OksObject* o(i->second);
    std::ostringstream s;
    OksData* d(o->GetAttributeValue(&di));
 
    if (alist) {
      for (std::list<OksAttribute*>::const_iterator j = alist->begin(); j != alist->end(); ++j, ++d) {
        s << (*j)->get_name() << *d << '\n';
      }
    }
 
    if (rlist) {
      for (std::list<OksRelationship*>::const_iterator j = rlist->begin(); j != rlist->end(); ++j, ++d) {
        s << (*j)->get_name() << *d << '\n';
      }
    }
 
    s << std::ends;
 
    vals.insert(std::make_pair(s.str(), o));
  }
 
  std::string last;
  const OksObject* prev(0);
 
  for (std::multimap<std::string, const OksObject*>::iterator i = vals.begin(); i != vals.end();) {
    if (last == i->first) {
      ObjsSet equal_objs;
      equal_objs.insert(prev);
      equal_objs.insert(i->second);
      ++i;
      for (; i != vals.end(); ++i) {
        if (last == i->first) {
          equal_objs.insert(i->second);
        } else {
          if (!printed_class) {
            std::cout << "* found equal objects in class \'" << c->get_name() << "\'" << std::endl;
            printed_class = true;
          }
 
          std::cout << "  # the following " << equal_objs.size() << " objects are equal:\n";
          for (ObjsSet::const_iterator j = equal_objs.begin(); j != equal_objs.end(); ++j) {
            std::cout << "   - " << (*j) << " from \'" << (*j)->get_file()->get_full_file_name() << "\'\n";
          }
 
          last = i->first;
          prev = i->second;
          ++i;
          break;
        }
      }
    } else {
      last = i->first;
      prev = i->second;
      ++i;
    }
  }
}
 
namespace po = boost::program_options;
 
int
main(int argc, char** argv)
{
  std::vector<std::string> files;
  std::string class_name;
  bool verbose(false);
 
  try {
    po::options_description desc("This program is loading OKS data files and searching for equal object.\nUsage: "
                                 "oks_report_equal_objects [options] [-f] file+  ");
 
    desc.add_options()(
      "class,c", po::value<std::string>(&class_name), "If defined, only compare objects of this class")(
      "files,f", po::value<std::vector<std::string>>(&files), "Names of input OKS files")(
      "verbose,v", "Run in verbose mode")("help,h", "Print help message");
 
    po::positional_options_description p;
    p.add("files", -1);
 
    po::variables_map vm;
    po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
    po::notify(vm);
 
    if (vm.count("help")) {
      std::cout << desc << std::endl;
      return EXIT_SUCCESS;
    }
    if (vm.count("verbose")) {
      verbose = true;
    }
 
    if (files.empty()) {
      throw std::runtime_error("Missing application name");
    }
  } catch (std::exception& ex) {
    std::cerr << "ERROR: " << ex.what() << std::endl;
    return EXIT_FAILURE;
  }
 
  try {
    OksKernel kernel;
    kernel.set_test_duplicated_objects_via_inheritance_mode(true);
    kernel.set_silence_mode(!verbose);
 
    for (std::vector<std::string>::const_iterator i = files.begin(); i != files.end(); ++i) {
      kernel.load_file(*i);
    }
 
    if (!class_name.empty()) {
      if (OksClass* c = kernel.find_class(class_name)) {
        process_class(c, verbose);
        return 0;
      } else {
        std::cerr << "ERROR: cannot find class \'" << class_name << '\'' << std::endl;
        return EXIT_FAILURE;
      }
    }
 
    for (OksClass::Map::const_iterator i = kernel.classes().begin(); i != kernel.classes().end(); ++i) {
      process_class(i->second, verbose);
    }
  } catch (oks::exception& ex) {
    std::cerr << "ERROR: " << ex.what() << std::endl;
    return EXIT_FAILURE;
  }
 
  return 0;
}