dump_dunedaq__timinglibs__dal.cpp File Reference

#include "conffwk/ConfigObject.hpp"
#include "conffwk/Configuration.hpp"
#include "timinglibs/dal/EndpointLocation.hpp"
#include "timinglibs/dal/TimingController.hpp"
#include "timinglibs/dal/TimingControllerConf.hpp"
#include "timinglibs/dal/TimingEndpointController.hpp"
#include "timinglibs/dal/TimingEndpointControllerBase.hpp"
#include "timinglibs/dal/TimingEndpointControllerConf.hpp"
#include "timinglibs/dal/TimingFanoutController.hpp"
#include "timinglibs/dal/TimingFanoutControllerConf.hpp"
#include "timinglibs/dal/TimingFanoutDevice.hpp"
#include "timinglibs/dal/TimingHardwareInterface.hpp"
#include "timinglibs/dal/TimingHardwareInterfaceConf.hpp"
#include "timinglibs/dal/TimingHardwareManagerBase.hpp"
#include "timinglibs/dal/TimingHardwareManagerConf.hpp"
#include "timinglibs/dal/TimingHardwareManagerPDII.hpp"
#include "timinglibs/dal/TimingMasterControllerBase.hpp"
#include "timinglibs/dal/TimingMasterControllerConf.hpp"
#include "timinglibs/dal/TimingMasterControllerPDII.hpp"
#include "timinglibs/dal/TimingMasterEndpointScanPayload.hpp"

Include dependency graph for dump_dunedaq__timinglibs__dal.cpp:

Go to the source code of this file.

Functions
static void	usage (const char *s)
static void	no_param (const char *s)
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 52 of file dump_dunedaq__timinglibs__dal.cpp.

{
    // parse parameters
 
  const char * db_name = nullptr;
  const char * object_id = nullptr;
  const char * query = "";
  std::string class_name;
  bool init_children = false;
 
  for(int i = 1; i < argc; i++) {
    const char * cp = argv[i];
    if(!strcmp(cp, "-h") || !strcmp(cp, "--help")) {
      usage(argv[0]);
      return 0;
    }
    if(!strcmp(cp, "-t") || !strcmp(cp, "--init-children")) {
      init_children = true;
    }
    else if(!strcmp(cp, "-d") || !strcmp(cp, "--data")) {
      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { db_name = argv[i]; }
    }
    else if(!strcmp(cp, "-c") || !strcmp(cp, "--class-name")) {
      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { class_name = argv[i]; }
    }
    else if(!strcmp(cp, "-i") || !strcmp(cp, "--object-id")) {
      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { object_id = argv[i]; }
    }
    else if(!strcmp(cp, "-q") || !strcmp(cp, "--query")) {
      if(++i == argc || argv[i][0] == '-') { no_param(cp); } else { query = argv[i]; }
    }
    else {
      std::cerr << "ERROR: bad parameter " << cp << std::endl;
      usage(argv[0]);
      return (EXIT_FAILURE);
    }
  }
 
  if(db_name == nullptr) {
    std::cerr << "ERROR: no database name provided\n";
    return (EXIT_FAILURE);
  }
 
  if(class_name.empty()) {
    std::cerr << "ERROR: no class name provided\n";
    return (EXIT_FAILURE);
  }
 
  if(*query != 0 && object_id != nullptr) {
    std::cerr << "ERROR: only one parameter -i or -q can be provided\n";
    return (EXIT_FAILURE);
  }
 
 
std::cout << std::boolalpha;
 
  try {
    dunedaq::conffwk::Configuration conf(db_name);
 
    if(!conf.loaded()) {
      std::cerr << "Can not load database: " << db_name << std::endl;
      return (EXIT_FAILURE);
    }
    
    std::vector< dunedaq::conffwk::ConfigObject > objects;
    
    if(object_id) {
      dunedaq::conffwk::ConfigObject obj;
      try {
        conf.get(class_name, object_id, obj, 1);
      }
      catch (dunedaq::conffwk::NotFound & ex) {
        std::cerr << "Can not get object \'" << object_id << "\' of class \'" << class_name << "\':\n" << ex << std::endl;
        return (EXIT_FAILURE);
      }
      objects.push_back(obj);
    }
    else {
      try {
        conf.get(class_name, objects, query, 1);
      }
      catch (dunedaq::conffwk::NotFound & ex) {
        std::cerr << "Can not get objects of class \'" << class_name << "\':\n" << ex << std::endl;
        return (EXIT_FAILURE);
      }
    }
    
    struct SortByUId {
      bool operator() (const dunedaq::conffwk::ConfigObject * o1, const dunedaq::conffwk::ConfigObject * o2) const {
        return (o1->UID() < o2->UID());
      };
    };
    
    std::set< dunedaq::conffwk::ConfigObject *, SortByUId > sorted_objects;
    
    for(auto& i : objects)
      sorted_objects.insert(&i);
    
    for(auto& i : sorted_objects) {
      if(class_name == "EndpointLocation") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::EndpointLocation>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingController") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingController>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingControllerConf") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingControllerConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingEndpointController") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingEndpointController>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingEndpointControllerBase") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingEndpointControllerBase>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingEndpointControllerConf") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingEndpointControllerConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingFanoutController") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingFanoutController>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingFanoutControllerConf") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingFanoutControllerConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingFanoutDevice") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingFanoutDevice>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingHardwareInterface") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingHardwareInterface>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingHardwareInterfaceConf") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingHardwareInterfaceConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingHardwareManagerBase") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingHardwareManagerBase>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingHardwareManagerConf") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingHardwareManagerConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingHardwareManagerPDII") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingHardwareManagerPDII>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingMasterControllerBase") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingMasterControllerBase>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingMasterControllerConf") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingMasterControllerConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingMasterControllerPDII") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingMasterControllerPDII>(*i, init_children) << std::endl;
      }
      else if(class_name == "TimingMasterEndpointScanPayload") {
        std::cout << *conf.get<dunedaq::timinglibs::dal::TimingMasterEndpointScanPayload>(*i, init_children) << std::endl;
      }
      else {
        std::cerr << "ERROR: do not know how to dump object of " << class_name << " class\n";
        return (EXIT_FAILURE);
      }
    }
  }
  catch (dunedaq::conffwk::Exception & ex) {
    std::cerr << "Caught " << ex << std::endl;
    return (EXIT_FAILURE);
  }
 
  return 0;
}

no_param()

static void no_param ( const char * s )

static

Definition at line 46 of file dump_dunedaq__timinglibs__dal.cpp.

{
  std::cerr << "ERROR: the required argument for option \'" << s << "\' is missing\n\n";
  exit (EXIT_FAILURE);
}

usage()

static void usage ( const char * s )

static

Definition at line 26 of file dump_dunedaq__timinglibs__dal.cpp.

{
  std::cout << s << " -d db-name -c class-name [-q query | -i object-id] [-t]\n"
    "\n"
    "Options/Arguments:\n"
    "  -d | --data db-name            mandatory name of the database\n"
    "  -c | --class-name class-name   mandatory name of class\n"
    "  -q | --query query             optional query to select class objects\n"
    "  -i | --object-id object-id     optional identity to select one object\n"
    "  -t | --init-children           all referenced objects are initialized (is used\n"
    "                                 for debug purposes and performance measurements)\n"
    "  -h | --help                    print this message\n"
    "\n"
    "Description:\n"
    "  The program prints out object(s) of given class.\n"
    "  If no query or object id is provided, all objects of the class are printed.\n"
    "  It is automatically generated by oksdalgen utility.\n"
    "\n";
}