dump_dunedaq__confmodel.cpp File Reference

#include "conffwk/ConfigObject.hpp"
#include "conffwk/Configuration.hpp"
#include "confmodel/ActionPlan.hpp"
#include "confmodel/Application.hpp"
#include "confmodel/Connection.hpp"
#include "confmodel/ConnectionService.hpp"
#include "confmodel/ConnectivityService.hpp"
#include "confmodel/DaqApplication.hpp"
#include "confmodel/DaqModule.hpp"
#include "confmodel/DaqModulesGroup.hpp"
#include "confmodel/DaqModulesGroupById.hpp"
#include "confmodel/DaqModulesGroupByType.hpp"
#include "confmodel/DetDataReceiver.hpp"
#include "confmodel/DetDataSender.hpp"
#include "confmodel/DetectorConfig.hpp"
#include "confmodel/DetectorStream.hpp"
#include "confmodel/DetectorToDaqConnection.hpp"
#include "confmodel/DummyApplication.hpp"
#include "confmodel/DummyD2D.hpp"
#include "confmodel/DummyReceiver.hpp"
#include "confmodel/DummyResource.hpp"
#include "confmodel/DummyResourceSet.hpp"
#include "confmodel/DummyResourceSetAND.hpp"
#include "confmodel/DummySender.hpp"
#include "confmodel/DummySmartResource.hpp"
#include "confmodel/DummyStream.hpp"
#include "confmodel/FSMCommand.hpp"
#include "confmodel/FSMaction.hpp"
#include "confmodel/FSMconfiguration.hpp"
#include "confmodel/FSMsequence.hpp"
#include "confmodel/FSMtransition.hpp"
#include "confmodel/FSMxTransition.hpp"
#include "confmodel/GeoId.hpp"
#include "confmodel/HostComponent.hpp"
#include "confmodel/Jsonable.hpp"
#include "confmodel/JsonableTest.hpp"
#include "confmodel/NetworkConnection.hpp"
#include "confmodel/NetworkDevice.hpp"
#include "confmodel/NetworkInterface.hpp"
#include "confmodel/OpMonConf.hpp"
#include "confmodel/OpMonURI.hpp"
#include "confmodel/PhysicalHost.hpp"
#include "confmodel/ProcessingResource.hpp"
#include "confmodel/Queue.hpp"
#include "confmodel/QueueWithSourceId.hpp"
#include "confmodel/RCApplication.hpp"
#include "confmodel/RCBroadcaster.hpp"
#include "confmodel/Resource.hpp"
#include "confmodel/ResourceSet.hpp"
#include "confmodel/ResourceSetDisableAND.hpp"
#include "confmodel/ResourceSetDisableOR.hpp"
#include "confmodel/ResourceTree.hpp"
#include "confmodel/Segment.hpp"
#include "confmodel/Service.hpp"
#include "confmodel/Session.hpp"
#include "confmodel/StorageDevice.hpp"
#include "confmodel/Variable.hpp"
#include "confmodel/VariableBase.hpp"
#include "confmodel/VariableSet.hpp"
#include "confmodel/VirtualHost.hpp"

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 92 of file dump_dunedaq__confmodel.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 == "ActionPlan") {
        std::cout << *conf.get<dunedaq::confmodel::ActionPlan>(*i, init_children) << std::endl;
      }
      else if(class_name == "Application") {
        std::cout << *conf.get<dunedaq::confmodel::Application>(*i, init_children) << std::endl;
      }
      else if(class_name == "Connection") {
        std::cout << *conf.get<dunedaq::confmodel::Connection>(*i, init_children) << std::endl;
      }
      else if(class_name == "ConnectionService") {
        std::cout << *conf.get<dunedaq::confmodel::ConnectionService>(*i, init_children) << std::endl;
      }
      else if(class_name == "ConnectivityService") {
        std::cout << *conf.get<dunedaq::confmodel::ConnectivityService>(*i, init_children) << std::endl;
      }
      else if(class_name == "DaqApplication") {
        std::cout << *conf.get<dunedaq::confmodel::DaqApplication>(*i, init_children) << std::endl;
      }
      else if(class_name == "DaqModule") {
        std::cout << *conf.get<dunedaq::confmodel::DaqModule>(*i, init_children) << std::endl;
      }
      else if(class_name == "DaqModulesGroup") {
        std::cout << *conf.get<dunedaq::confmodel::DaqModulesGroup>(*i, init_children) << std::endl;
      }
      else if(class_name == "DaqModulesGroupById") {
        std::cout << *conf.get<dunedaq::confmodel::DaqModulesGroupById>(*i, init_children) << std::endl;
      }
      else if(class_name == "DaqModulesGroupByType") {
        std::cout << *conf.get<dunedaq::confmodel::DaqModulesGroupByType>(*i, init_children) << std::endl;
      }
      else if(class_name == "DetDataReceiver") {
        std::cout << *conf.get<dunedaq::confmodel::DetDataReceiver>(*i, init_children) << std::endl;
      }
      else if(class_name == "DetDataSender") {
        std::cout << *conf.get<dunedaq::confmodel::DetDataSender>(*i, init_children) << std::endl;
      }
      else if(class_name == "DetectorConfig") {
        std::cout << *conf.get<dunedaq::confmodel::DetectorConfig>(*i, init_children) << std::endl;
      }
      else if(class_name == "DetectorStream") {
        std::cout << *conf.get<dunedaq::confmodel::DetectorStream>(*i, init_children) << std::endl;
      }
      else if(class_name == "DetectorToDaqConnection") {
        std::cout << *conf.get<dunedaq::confmodel::DetectorToDaqConnection>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyApplication") {
        std::cout << *conf.get<dunedaq::confmodel::DummyApplication>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyD2D") {
        std::cout << *conf.get<dunedaq::confmodel::DummyD2D>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyReceiver") {
        std::cout << *conf.get<dunedaq::confmodel::DummyReceiver>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyResource") {
        std::cout << *conf.get<dunedaq::confmodel::DummyResource>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyResourceSet") {
        std::cout << *conf.get<dunedaq::confmodel::DummyResourceSet>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyResourceSetAND") {
        std::cout << *conf.get<dunedaq::confmodel::DummyResourceSetAND>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummySender") {
        std::cout << *conf.get<dunedaq::confmodel::DummySender>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummySmartResource") {
        std::cout << *conf.get<dunedaq::confmodel::DummySmartResource>(*i, init_children) << std::endl;
      }
      else if(class_name == "DummyStream") {
        std::cout << *conf.get<dunedaq::confmodel::DummyStream>(*i, init_children) << std::endl;
      }
      else if(class_name == "FSMCommand") {
        std::cout << *conf.get<dunedaq::confmodel::FSMCommand>(*i, init_children) << std::endl;
      }
      else if(class_name == "FSMaction") {
        std::cout << *conf.get<dunedaq::confmodel::FSMaction>(*i, init_children) << std::endl;
      }
      else if(class_name == "FSMconfiguration") {
        std::cout << *conf.get<dunedaq::confmodel::FSMconfiguration>(*i, init_children) << std::endl;
      }
      else if(class_name == "FSMsequence") {
        std::cout << *conf.get<dunedaq::confmodel::FSMsequence>(*i, init_children) << std::endl;
      }
      else if(class_name == "FSMtransition") {
        std::cout << *conf.get<dunedaq::confmodel::FSMtransition>(*i, init_children) << std::endl;
      }
      else if(class_name == "FSMxTransition") {
        std::cout << *conf.get<dunedaq::confmodel::FSMxTransition>(*i, init_children) << std::endl;
      }
      else if(class_name == "GeoId") {
        std::cout << *conf.get<dunedaq::confmodel::GeoId>(*i, init_children) << std::endl;
      }
      else if(class_name == "HostComponent") {
        std::cout << *conf.get<dunedaq::confmodel::HostComponent>(*i, init_children) << std::endl;
      }
      else if(class_name == "Jsonable") {
        std::cout << *conf.get<dunedaq::confmodel::Jsonable>(*i, init_children) << std::endl;
      }
      else if(class_name == "JsonableTest") {
        std::cout << *conf.get<dunedaq::confmodel::JsonableTest>(*i, init_children) << std::endl;
      }
      else if(class_name == "NetworkConnection") {
        std::cout << *conf.get<dunedaq::confmodel::NetworkConnection>(*i, init_children) << std::endl;
      }
      else if(class_name == "NetworkDevice") {
        std::cout << *conf.get<dunedaq::confmodel::NetworkDevice>(*i, init_children) << std::endl;
      }
      else if(class_name == "NetworkInterface") {
        std::cout << *conf.get<dunedaq::confmodel::NetworkInterface>(*i, init_children) << std::endl;
      }
      else if(class_name == "OpMonConf") {
        std::cout << *conf.get<dunedaq::confmodel::OpMonConf>(*i, init_children) << std::endl;
      }
      else if(class_name == "OpMonURI") {
        std::cout << *conf.get<dunedaq::confmodel::OpMonURI>(*i, init_children) << std::endl;
      }
      else if(class_name == "PhysicalHost") {
        std::cout << *conf.get<dunedaq::confmodel::PhysicalHost>(*i, init_children) << std::endl;
      }
      else if(class_name == "ProcessingResource") {
        std::cout << *conf.get<dunedaq::confmodel::ProcessingResource>(*i, init_children) << std::endl;
      }
      else if(class_name == "Queue") {
        std::cout << *conf.get<dunedaq::confmodel::Queue>(*i, init_children) << std::endl;
      }
      else if(class_name == "QueueWithSourceId") {
        std::cout << *conf.get<dunedaq::confmodel::QueueWithSourceId>(*i, init_children) << std::endl;
      }
      else if(class_name == "RCApplication") {
        std::cout << *conf.get<dunedaq::confmodel::RCApplication>(*i, init_children) << std::endl;
      }
      else if(class_name == "RCBroadcaster") {
        std::cout << *conf.get<dunedaq::confmodel::RCBroadcaster>(*i, init_children) << std::endl;
      }
      else if(class_name == "Resource") {
        std::cout << *conf.get<dunedaq::confmodel::Resource>(*i, init_children) << std::endl;
      }
      else if(class_name == "ResourceSet") {
        std::cout << *conf.get<dunedaq::confmodel::ResourceSet>(*i, init_children) << std::endl;
      }
      else if(class_name == "ResourceSetDisableAND") {
        std::cout << *conf.get<dunedaq::confmodel::ResourceSetDisableAND>(*i, init_children) << std::endl;
      }
      else if(class_name == "ResourceSetDisableOR") {
        std::cout << *conf.get<dunedaq::confmodel::ResourceSetDisableOR>(*i, init_children) << std::endl;
      }
      else if(class_name == "ResourceTree") {
        std::cout << *conf.get<dunedaq::confmodel::ResourceTree>(*i, init_children) << std::endl;
      }
      else if(class_name == "Segment") {
        std::cout << *conf.get<dunedaq::confmodel::Segment>(*i, init_children) << std::endl;
      }
      else if(class_name == "Service") {
        std::cout << *conf.get<dunedaq::confmodel::Service>(*i, init_children) << std::endl;
      }
      else if(class_name == "Session") {
        std::cout << *conf.get<dunedaq::confmodel::Session>(*i, init_children) << std::endl;
      }
      else if(class_name == "StorageDevice") {
        std::cout << *conf.get<dunedaq::confmodel::StorageDevice>(*i, init_children) << std::endl;
      }
      else if(class_name == "Variable") {
        std::cout << *conf.get<dunedaq::confmodel::Variable>(*i, init_children) << std::endl;
      }
      else if(class_name == "VariableBase") {
        std::cout << *conf.get<dunedaq::confmodel::VariableBase>(*i, init_children) << std::endl;
      }
      else if(class_name == "VariableSet") {
        std::cout << *conf.get<dunedaq::confmodel::VariableSet>(*i, init_children) << std::endl;
      }
      else if(class_name == "VirtualHost") {
        std::cout << *conf.get<dunedaq::confmodel::VirtualHost>(*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()

void no_param ( const char * s )

static

Definition at line 86 of file dump_dunedaq__confmodel.cpp.

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

usage()

void usage ( const char * s )

static

Definition at line 66 of file dump_dunedaq__confmodel.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";
}