Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-09-11 09:33:08 

0001 
0002 #include "JInspector.h"
0003 #include <JANA/JEventSource.h>
0004 #include <stack>
0005 #include <JANA/Utils/JTablePrinter.h>
0006 
0007 
0008 JInspector::JInspector(const JEvent* event) : m_event(event) {}
0009 
0010 void JInspector::Reset() {
0011     m_indexes_built = false;
0012     m_factories.clear();
0013     m_factory_index.clear();
0014     m_discrepancies.clear();
0015 }
0016 
0017 void JInspector::SetDiscrepancies(std::set<std::string>&& diverging_factory_keys) {
0018     m_discrepancies = std::move(diverging_factory_keys);
0019 }
0020 
0021 void JInspector::BuildIndices() {
0022     if (m_indexes_built) return;
0023     for (auto fac: m_event->GetFactorySet()->GetAllFactories()) {
0024         m_factories.push_back(fac);
0025     }
0026     std::sort(m_factories.begin(), m_factories.end(), [](const JFactory* first, const JFactory* second){
0027         return std::make_pair(first->GetObjectName(), first->GetTag()) <
0028                std::make_pair(second->GetObjectName(), second->GetTag());});
0029 
0030     int i = 0;
0031     for (auto fac : m_factories) {
0032         std::string key = MakeFactoryKey(fac->GetObjectName(), fac->GetTag());
0033         std::pair<int, const JFactory*> value = {i++, fac};
0034         m_factory_index.insert({key, value});
0035         m_factory_index.insert({std::to_string(i), value});
0036     }
0037     m_indexes_built = true;
0038 }
0039 
0040 std::vector<const JObject*> JInspector::FindAllAncestors(const JObject* root) {
0041     std::vector<const JObject*> all_ancestors;
0042     std::stack<const JObject*> to_visit;
0043     to_visit.push(root);
0044     while (!to_visit.empty()) {
0045         auto current_obj = to_visit.top();
0046         to_visit.pop();
0047         all_ancestors.push_back(current_obj);
0048         std::vector<const JObject*> current_ancestors;
0049         current_obj->GetT<JObject>(current_ancestors);
0050         for (auto obj : current_ancestors) {
0051             to_visit.push(obj);
0052         }
0053     }
0054     return all_ancestors;
0055 }
0056 
0057 std::tuple<JFactory*, size_t, size_t> JInspector::LocateObject(const JEvent& event, const JObject* obj) {
0058     auto objName = obj->className();
0059     size_t fac_idx = 0;
0060     for (auto fac : event.GetAllFactories()) {
0061         if (fac->GetObjectName() == objName) {
0062             size_t obj_idx = 0;
0063             for (auto o : fac->GetAs<JObject>()) { // Won't trigger factory creation if it hasn't already happened
0064                 if (obj == o) {
0065                     return std::make_tuple(fac, fac_idx, obj_idx);
0066                 }
0067                 obj_idx++;
0068             }
0069         }
0070         fac_idx++;
0071     }
0072     return std::make_tuple(nullptr, -1, -1);
0073 }
0074 
0075 void JInspector::PrintEvent() {
0076     ToText(m_event, m_format==Format::Json, m_out);
0077 }
0078 void JInspector::PrintFactories(int filter_level=0) {
0079     BuildIndices();
0080     ToText(m_factories, m_discrepancies, filter_level, m_format==Format::Json, m_out);
0081 }
0082 
0083 void JInspector::PrintObjects(std::string factory_key) {
0084     BuildIndices();
0085     auto result = m_factory_index.find(factory_key);
0086     if (result == m_factory_index.end()) {
0087         m_out << "(Error: Invalid factory name or index)\n";
0088         return;
0089     }
0090     auto fac = const_cast<JFactory*>(result->second.second);
0091     auto objs = fac->GetAs<JObject>();
0092     ToText(objs, m_format==Format::Json, m_out);
0093 }
0094 
0095 void JInspector::PrintFactoryDetails(std::string fac_key) {
0096     BuildIndices();
0097     auto result = m_factory_index.find(fac_key);
0098     if (result == m_factory_index.end()) {
0099         m_out << "(Error: Invalid factory name or index)\n";
0100         return;
0101     }
0102     auto fac = result->second.second;
0103     ToText(fac, m_format==Format::Json, m_out);
0104 }
0105 
0106 void JInspector::PrintObject(std::string fac_key, int object_idx) {
0107     BuildIndices();
0108     auto result = m_factory_index.find(fac_key);
0109     if (result == m_factory_index.end()) {
0110         m_out << "(Error: Invalid factory name or index)\n";
0111         return;
0112     }
0113     JFactory* fac = const_cast<JFactory*>(result->second.second);
0114     auto objs = fac->GetAs<JObject>();
0115     if ((size_t) object_idx >= objs.size()) {
0116         m_out << "(Error: Object index out of range)" << std::endl;
0117         return;
0118     }
0119     auto obj = objs[object_idx];
0120     ToText(obj, m_format==Format::Json, m_out);
0121 }
0122 std::string JInspector::MakeFactoryKey(std::string name, std::string tag) {
0123     std::ostringstream ss;
0124     ss << name;
0125     if (!tag.empty()) {
0126         ss << ":" << tag;
0127     }
0128     return ss.str();
0129 }
0130 
0131 void JInspector::PrintHelp() {
0132     m_out << "  -----------------------------------------" << std::endl;
0133     m_out << "  Available commands" << std::endl;
0134     m_out << "  -----------------------------------------" << std::endl;
0135     m_out << "  pe   PrintEvent" << std::endl;
0136     m_out << "  pf   PrintFactories [filter_level <- {0,1,2,3}]" << std::endl;
0137     m_out << "  pfd  PrintFactoryDetails fac_idx" << std::endl;
0138     m_out << "  po   PrintObjects fac_idx" << std::endl;
0139     m_out << "  po   PrintObject fac_idx obj_idx" << std::endl;
0140     m_out << "  pfp  PrintFactoryParents fac_idx" << std::endl;
0141     m_out << "  pop  PrintObjectParents fac_idx obj_idx" << std::endl;
0142     m_out << "  poa  PrintObjectAncestors fac_idx obj_idx" << std::endl;
0143     m_out << "  vt   ViewAsTable" << std::endl;
0144     m_out << "  vj   ViewAsJson" << std::endl;
0145     m_out << "  x    Exit" << std::endl;
0146     m_out << "  h    Help" << std::endl;
0147     m_out << "  -----------------------------------------" << std::endl;
0148 }
0149 void JInspector::ToText(const JEvent* event, bool asJson, std::ostream& out) {
0150     auto className = event->GetJEventSource()->GetTypeName();
0151     if (className.empty()) className = "(unknown)";
0152     if (asJson) {
0153         out << "{ \"run_number\": " << event->GetRunNumber();
0154         out << ", \"event_number\": " << event->GetEventNumber();
0155         out << ", \"source\": \"" << event->GetJEventSource()->GetResourceName();
0156         out << "\", \"class_name\": \"" << className;
0157         out << "\", \"is_sequential\": \"" << event->GetSequential() << "\"}";
0158         out << std::endl;
0159     }
0160     else {
0161         out << "Run number:   " << event->GetRunNumber() << std::endl;
0162         out << "Event number: " << event->GetEventNumber() << std::endl;
0163         out << "Event source: " << event->GetJEventSource()->GetResourceName() << std::endl;
0164         out << "Class name:   " << className << std::endl;
0165         out << "Sequential:   " << event->GetSequential() << std::endl;
0166     }
0167 }
0168 
0169 void JInspector::ToText(const JFactory* fac, bool asJson, std::ostream& out) {
0170 
0171     auto pluginName = fac->GetPluginName();
0172     if (pluginName.empty()) pluginName = "(no plugin)";
0173 
0174     auto factoryName = fac->GetFactoryName();
0175     // if (factoryName.empty()) factoryName = "(no name)";
0176 
0177     auto tag = fac->GetTag();
0178     if (tag.empty()) tag = "(no tag)";
0179 
0180     std::string status;
0181     switch (fac->GetStatus()) {
0182         case JFactory::Status::Empty: status = "Empty"; break;
0183         case JFactory::Status::Processed: status = "Processed"; break;
0184         case JFactory::Status::Inserted: status = "Inserted"; break;
0185         case JFactory::Status::Excepted: status = "Excepted"; break;
0186         default: status = "Unknown";
0187     }
0188 
0189     if (!asJson) {
0190         out << "Plugin name          " << pluginName << std::endl;
0191         out << "Type name            " << factoryName << std::endl;
0192         out << "Object name          " << fac->GetObjectName() << std::endl;
0193         out << "Tag                  " << tag << std::endl;
0194         out << "Status               " << status << std::endl;
0195         out << "Object count         " << fac->GetNumObjects() << std::endl;
0196     }
0197     else {
0198         out << "{" << std::endl;
0199         out << "  \"plugin_name\":   \"" << pluginName << "\"," << std::endl;
0200         out << "  \"factory_name\":  \"" << factoryName << "\"," << std::endl;
0201         out << "  \"object_name\":   \"" << fac->GetObjectName() << "\"," << std::endl;
0202         out << "  \"tag\":           \"" << tag << "\"," << std::endl;
0203         out << "  \"status\":        \"" << status << "\"," << std::endl;
0204         out << "  \"object_count\":  " << fac->GetNumObjects() << "," << std::endl;
0205         out << "}" << std::endl;
0206     }
0207 }
0208 
0209 void JInspector::ToText(const std::vector<JFactory*>& factories, const std::set<std::string>& discrepancies, int filterlevel, bool asJson, std::ostream &out) {
0210     size_t idx = -1;
0211     if (!asJson) {
0212         JTablePrinter t;
0213         t.AddColumn("Index", JTablePrinter::Justify::Right);
0214         t.AddColumn("Object");
0215         t.AddColumn("Tag");
0216         t.AddColumn("Creation status");
0217         t.AddColumn("Object count", JTablePrinter::Justify::Right);
0218         t.AddColumn("Discrepancy", JTablePrinter::Justify::Right);
0219         for (auto fac : factories) {
0220             auto tag = fac->GetTag();
0221             if (tag.empty()) tag = "(no tag)";
0222             std::string status;
0223             switch (fac->GetStatus()) {
0224                 case JFactory::Status::Empty: status = "Empty"; break;
0225                 case JFactory::Status::Processed: status = "Processed"; break;
0226                 case JFactory::Status::Inserted: status = "Inserted"; break;
0227                 case JFactory::Status::Excepted: status = "Excepted"; break;
0228                 default: status = "Unknown";
0229             }
0230             idx += 1;
0231             if (filterlevel > 0 && (fac->GetStatus() == JFactory::Status::Empty)) continue;
0232 
0233             if (filterlevel > 1 && (fac->GetNumObjects()== 0)) continue;
0234 
0235             if (filterlevel > 2 && (fac->GetStatus() == JFactory::Status::Inserted)) continue;
0236 
0237             char discrepancy = ' ';
0238             auto key = MakeFactoryKey(fac->GetObjectName(), fac->GetTag());
0239             if (discrepancies.find(key) != discrepancies.end()) discrepancy = 'x';
0240 
0241             t | idx | fac->GetObjectName() | tag | status | fac->GetNumObjects() | discrepancy;
0242         }
0243         t.Render(out);
0244     }
0245     else {
0246         out << "{" << std::endl;
0247         for (auto fac : factories) {
0248             auto facName = fac->GetFactoryName();
0249             if (facName.empty()) facName = "null";
0250             auto tag = fac->GetTag();
0251             if (tag.empty()) tag = "null";
0252             out << "  " << idx++ << ": { \"factory_name\": ";
0253             if (fac->GetFactoryName().empty()) {
0254                 out << "null, ";
0255             }
0256             else {
0257                 out << "\"" << fac->GetFactoryName() << "\", ";
0258             }
0259             out << "\"object_name\": \"" << fac->GetObjectName() << "\", \"tag\": ";
0260             if (fac->GetTag().empty()) {
0261                 out << "null, ";
0262             }
0263             else {
0264                 out << "\"" << fac->GetTag() << "\", ";
0265             }
0266             out << "\"object_count\": " << fac->GetNumObjects();
0267             out << "}," << std::endl;
0268         }
0269         out << "}" << std::endl;
0270     }
0271 }
0272 
0273 void JInspector::ToText(std::vector<JObject*> objs, bool as_json, std::ostream& out) {
0274 
0275     if (objs.empty()) {
0276         out << "(No objects found)" << std::endl;
0277         return;
0278     }
0279     std::set<std::string> objnames;
0280     for (auto obj: objs) {
0281         objnames.insert(obj->className());
0282     }
0283     if (objnames.size() == 1) {
0284         out << *(objnames.begin()) << std::endl;
0285     }
0286     else {
0287         out << "{ ";
0288         for (auto name : objnames) {
0289             out << name << ",";
0290         }
0291         out << "}" << std::endl;
0292     }
0293     if (as_json) {
0294         out << "{" << std::endl;
0295         for (size_t i = 0; i < objs.size(); ++i) {
0296             auto obj = objs[i];
0297             JObjectSummary summary;
0298             obj->Summarize(summary);
0299             out << "  " << i << ":  {";
0300             for (auto& field : summary.get_fields()) {
0301                 out << "\"" << field.name << "\": \"" << field.value << "\", ";
0302             }
0303             out << "}" << std::endl;
0304         }
0305         out << "}" << std::endl;
0306     }
0307     else {
0308         JTablePrinter t;
0309         std::set<std::string> fieldnames_seen;
0310         std::vector<std::string> fieldnames_in_order;
0311         for (auto obj : objs) {
0312             JObjectSummary summary;
0313             obj->Summarize(summary);
0314             for (auto field : summary.get_fields()) {
0315                 if (fieldnames_seen.find(field.name) == fieldnames_seen.end()) {
0316                     fieldnames_in_order.push_back(field.name);
0317                     fieldnames_seen.insert(field.name);
0318                 }
0319             }
0320         }
0321         t.AddColumn("Index");
0322         for (auto fieldname : fieldnames_in_order) {
0323             t.AddColumn(fieldname);
0324         }
0325         for (size_t i = 0; i < objs.size(); ++i) {
0326             auto obj = objs[i];
0327             t | i;
0328             std::map<std::string, std::string> summary_map;
0329             JObjectSummary summary;
0330             obj->Summarize(summary);
0331             for (auto& field : summary.get_fields()) {
0332                 summary_map[field.name] = field.value;
0333             }
0334             for (auto& fieldname : fieldnames_in_order) {
0335                 auto result = summary_map.find(fieldname);
0336                 if (result == summary_map.end()) {
0337                     t | "(missing)";
0338                 }
0339                 else {
0340                     t | result->second;
0341                 }
0342             }
0343         }
0344         t.Render(out);
0345     }
0346 }
0347 
0348 void JInspector::ToText(const JObject* obj, bool asJson, std::ostream& out) {
0349     out << obj->className() << std::endl;
0350     JObjectSummary summary;
0351     obj->Summarize(summary);
0352     if (asJson) {
0353         out << "[" << std::endl;
0354         for (auto& field : summary.get_fields()) {
0355             out << "  { \"name\": \"" << field.name << "\", ";
0356             out << "\"value\": \"" << field.value << "\", ";
0357             out << "\"description\": \"" << field.description << "\" }" << std::endl;
0358         }
0359         out << "]" << std::endl;
0360     }
0361     else {
0362         JTablePrinter t;
0363         t.AddColumn("Field name");
0364         t.AddColumn("Value");
0365         t.AddColumn("Description");
0366         for (auto& field : summary.get_fields()) {
0367             t | field.name | field.value | field.description;
0368         }
0369         t.Render(out);
0370     }
0371 }
0372 
0373 void JInspector::PrintFactoryParents(std::string factory_idx) {
0374 
0375     bool callgraph_on = m_event->GetJCallGraphRecorder()->IsEnabled();
0376     if (!callgraph_on) {
0377         m_out << "(Error: Callgraph recording is currently disabled)" << std::endl;
0378     }
0379 
0380     BuildIndices();  // So that we can retrieve the integer index given the factory name/tag pair
0381     auto result = m_factory_index.find(factory_idx);
0382     if (result == m_factory_index.end()) {
0383         m_out << "(Error: Invalid factory name or index)\n";
0384         return;
0385     }
0386     auto fac = result->second.second;
0387     auto obj_name = fac->GetObjectName();
0388     auto fac_tag = fac->GetTag();
0389     if (fac_tag.empty()) {
0390         m_out << obj_name << std::endl;
0391     }
0392     else {
0393         m_out << obj_name << ":" << fac_tag << std::endl;
0394     }
0395 
0396     if (m_format != Format::Json) {
0397         JTablePrinter t;
0398         t.AddColumn("Index", JTablePrinter::Justify::Right);
0399         t.AddColumn("Object name");
0400         t.AddColumn("Tag");
0401         auto callgraph = m_event->GetJCallGraphRecorder()->GetCallGraph();
0402         bool found_anything = false;
0403         for (const auto& node : callgraph) {
0404             if ((node.caller_name == obj_name) && (node.caller_tag == fac_tag)) {
0405                 found_anything = true;
0406                 auto idx = m_factory_index[MakeFactoryKey(node.callee_name, node.callee_tag)].first;
0407                 auto tag = node.callee_tag;
0408                 if (tag.empty()) tag = "(no tag)";
0409                 t | idx | node.callee_name | tag;
0410             }
0411         }
0412         if (!found_anything) {
0413             m_out << "(No parents found)" << std::endl;
0414             return;
0415         }
0416         t.Render(m_out);
0417     }
0418     else {
0419         auto callgraph = m_event->GetJCallGraphRecorder()->GetCallGraph();
0420         bool found_anything = false;
0421         m_out << "[" << std::endl;
0422         for (const auto& node : callgraph) {
0423             if ((node.caller_name == obj_name) && (node.caller_tag == fac_tag)) {
0424                 found_anything = true;
0425                 auto idx = m_factory_index[MakeFactoryKey(node.callee_name, node.callee_tag)].first;
0426                 auto tag = node.callee_tag;
0427                 m_out << "  { \"index\": " << idx << ", \"object_name\": \"" << node.callee_name << "\", \"tag\": ";
0428                 if (tag.empty()) {
0429                     m_out << "null }," << std::endl;
0430                 }
0431                 else {
0432                     m_out << "\"" << tag << "\" }," << std::endl;
0433                 }
0434             }
0435         }
0436         m_out << "]" << std::endl;
0437         if (!found_anything) {
0438             m_out << "(No ancestors found)" << std::endl;
0439             return;
0440         }
0441     }
0442 }
0443 
0444 void JInspector::PrintObjectParents(std::string factory_key, int object_idx) {
0445 
0446     BuildIndices();  // So that we can retrieve the integer index given the factory name/tag pair
0447     auto result = m_factory_index.find(factory_key);
0448     if (result == m_factory_index.end()) {
0449         m_out << "(Error: Invalid factory name or index)\n";
0450         return;
0451     }
0452     auto fac = const_cast<JFactory*>(result->second.second);
0453     auto objs = fac->GetAs<JObject>();
0454     if ((size_t) object_idx >= objs.size()) {
0455         m_out << "(Error: Object index out of range)" << std::endl;
0456         return;
0457     }
0458     auto obj = objs[object_idx];
0459     m_out << obj->className() << std::endl;
0460     std::vector<const JObject*> parents;
0461     obj->GetT<JObject>(parents);
0462     if (parents.empty()) {
0463         m_out << "(No parents found)" << std::endl;
0464         return;
0465     }
0466 
0467     if (m_format == Format::Table) {
0468         JTablePrinter t;
0469         t.AddColumn("Object name");
0470         t.AddColumn("Tag");
0471         t.AddColumn("Factory Index", JTablePrinter::Justify::Right);
0472         t.AddColumn("Object Index", JTablePrinter::Justify::Right);
0473         t.AddColumn("Object contents");
0474         for (auto parent : parents) {
0475             JFactory* fac;
0476             size_t fac_idx;
0477             size_t obj_idx;
0478             std::tie(fac, fac_idx, obj_idx) = LocateObject(*m_event, parent);
0479             if (fac == nullptr) {
0480                 m_out << "(Error: Unable to find factory containing object with classname '" << obj->className() << "')" << std::endl;
0481                 continue;
0482             }
0483             JObjectSummary summary;
0484             parent->Summarize(summary);
0485 
0486             auto tag = fac->GetTag();
0487             if (tag.empty()) tag = "(no tag)";
0488             std::ostringstream objval;
0489             objval << "{";
0490             for (auto& field : summary.get_fields()) {
0491                 objval << field.name << ": " << field.value << ", ";
0492             }
0493             objval << "}";
0494 
0495             t | fac->GetObjectName() | tag | fac_idx | obj_idx | objval.str();
0496         }
0497         t.Render(m_out);
0498     }
0499     else {
0500         m_out << "[" << std::endl;
0501         for (auto ancestor : FindAllAncestors(obj)) {
0502             JFactory* fac;
0503             size_t fac_idx;
0504             size_t obj_idx;
0505             std::tie(fac, fac_idx, obj_idx) = LocateObject(*m_event, ancestor);
0506             if (fac == nullptr) {
0507                 m_out << "(Error: Unable to find factory containing object with classname '" << obj->className() << "')" << std::endl;
0508                 continue;
0509             }
0510             auto tag = fac->GetTag();
0511             if (tag.empty()) tag = "(no tag)";
0512 
0513             m_out << "  " << "{ " << std::endl << "    \"object_name\": \"" << fac->GetObjectName() << "\", ";
0514             if (tag.empty()) {
0515                 m_out << "\"tag\": null, ";
0516             }
0517             else {
0518                 m_out << "\"tag\": \"" << tag << "\", ";
0519             }
0520             m_out << "\"fac_index\": " << fac_idx << ", \"obj_index\": " << obj_idx << "," << std::endl;
0521             m_out << "    \"object_contents\": ";
0522 
0523             JObjectSummary summary;
0524             ancestor->Summarize(summary);
0525             m_out << "{";
0526             for (auto& field : summary.get_fields()) {
0527                 m_out << "\"" << field.name << "\": \"" << field.value << "\", ";
0528             }
0529             m_out << "}" << std::endl;
0530             m_out << "  }, " << std::endl;
0531         }
0532         m_out << "]" << std::endl;
0533     }
0534 }
0535 
0536 void JInspector::PrintObjectAncestors(std::string factory_idx, int object_idx) {
0537 
0538     BuildIndices();  // So that we can retrieve the integer index given the factory name/tag pair
0539     auto result = m_factory_index.find(factory_idx);
0540     if (result == m_factory_index.end()) {
0541         m_out << "(Error: Invalid factory name or index)\n";
0542         return;
0543     }
0544     auto fac = const_cast<JFactory*>(result->second.second);
0545     auto objs = fac->GetAs<JObject>();
0546     if ((size_t) object_idx >= objs.size()) {
0547         m_out << "(Error: Object index out of range)" << std::endl;
0548         return;
0549     }
0550     auto obj = objs[object_idx];
0551     m_out << obj->className() << std::endl;
0552     auto ancestors = FindAllAncestors(obj);
0553     if (ancestors.empty()) {
0554          m_out << "(No ancestors found)" << std::endl;
0555          return;
0556     }
0557 
0558     if (m_format == Format::Table) {
0559         JTablePrinter t;
0560         t.AddColumn("Object name");
0561         t.AddColumn("Tag");
0562         t.AddColumn("Factory index", JTablePrinter::Justify::Right);
0563         t.AddColumn("Object index", JTablePrinter::Justify::Right);
0564         t.AddColumn("Object contents");
0565         for (auto ancestor : FindAllAncestors(obj)) {
0566             JFactory* fac;
0567             size_t fac_idx, obj_idx;
0568             std::tie(fac, fac_idx, obj_idx) = LocateObject(*m_event, ancestor);
0569             if (fac == nullptr) {
0570                 m_out << "(Error: Unable to find factory containing object with classname '" << obj->className() << "')" << std::endl;
0571                 continue;
0572             }
0573             JObjectSummary summary;
0574             ancestor->Summarize(summary);
0575 
0576             auto tag = fac->GetTag();
0577             if (tag.empty()) tag = "(no tag)";
0578             std::ostringstream objval;
0579             objval << "{";
0580             for (auto& field : summary.get_fields()) {
0581                 objval << field.name << ": " << field.value << ", ";
0582             }
0583             objval << "}";
0584 
0585             t | fac->GetObjectName() | tag | fac_idx | obj_idx | objval.str();
0586         }
0587         t.Render(m_out);
0588     }
0589     else {
0590         m_out << "[" << std::endl;
0591         for (auto ancestor : FindAllAncestors(obj)) {
0592             JFactory* fac;
0593             size_t fac_idx, obj_idx;
0594             std::tie(fac, fac_idx, obj_idx) = LocateObject(*m_event, ancestor);
0595             if (fac == nullptr) {
0596                 m_out << "(Error: Unable to find factory containing object with classname '" << obj->className() << "')" << std::endl;
0597                 continue;
0598             }
0599             auto tag = fac->GetTag();
0600             if (tag.empty()) tag = "(no tag)";
0601 
0602             m_out << "  " << "{ " << std::endl << "    \"object_name\": \"" << fac->GetObjectName() << "\", ";
0603             if (tag.empty()) {
0604                 m_out << "\"tag\": null, ";
0605             }
0606             else {
0607                 m_out << "\"tag\": \"" << tag << "\", ";
0608             }
0609             m_out << "\"fac_index\": " << fac_idx << ", \"obj_index\": " << obj_idx << "," << std::endl;
0610             m_out << "    \"object_contents\": ";
0611 
0612             JObjectSummary summary;
0613             ancestor->Summarize(summary);
0614             m_out << "{";
0615             for (auto& field : summary.get_fields()) {
0616                 m_out << "\"" << field.name << "\": \"" << field.value << "\", ";
0617             }
0618             m_out << "}" << std::endl;
0619             m_out << "  }, " << std::endl;
0620         }
0621         m_out << "]" << std::endl;
0622     }
0623 }
0624 
0625 void JInspector::Loop() {
0626     bool stay_in_loop = true;
0627     auto app = m_event->GetJApplication();
0628     m_enable_timeout_on_exit = app->IsTimeoutEnabled();
0629     m_enable_ticker_on_exit = app->IsTickerEnabled();
0630     m_event->GetJApplication()->SetTicker( false );
0631     m_event->GetJApplication()->SetTimeoutEnabled( false );
0632     m_out << std::endl;
0633     m_out << "--------------------------------------------------------------------------------------" << std::endl;
0634     m_out << "Welcome to JANA's interactive inspector! Type `Help` or `h` to see available commands." << std::endl;
0635     m_out << "--------------------------------------------------------------------------------------" << std::endl;
0636     PrintEvent();
0637     while (stay_in_loop) {
0638         std::string user_input;
0639         m_out << std::endl << "JANA: "; m_out.flush();
0640         // Obtain a single line
0641         std::getline(m_in, user_input);
0642         // Split into tokens
0643         std::stringstream ss(user_input);
0644         std::string token;
0645         ss >> token;
0646         std::vector<std::string> args;
0647         std::string arg;
0648         while (ss >> arg) {
0649             args.push_back(arg);
0650         }
0651         try {
0652             if (token == "PrintEvent" || token == "pe") {
0653                 PrintEvent();
0654             }
0655             else if ((token == "PrintFactories" || token == "pf") && args.empty()) {
0656                 PrintFactories(0);
0657             }
0658             else if ((token == "PrintFactories" || token == "pf") && args.size() == 1) {
0659                 PrintFactories(std::stoi(args[0]));
0660             }
0661             else if ((token == "PrintFactoryDetails" || token == "pfd") && (args.size() == 1)) {
0662                 PrintFactoryDetails(args[0]);
0663             }
0664             else if ((token == "PrintObjects" || token == "po") && (args.size() == 1)) {
0665                 PrintObjects(args[0]);
0666             }
0667             else if ((token == "PrintObject" || token == "po") && (args.size() == 2)) {
0668                 PrintObject(args[0], std::stoi(args[1]));
0669             }
0670             else if ((token == "PrintFactoryParents" || token == "pfp") && (args.size() == 1)) {
0671                 PrintFactoryParents(args[0]);
0672             }
0673             else if ((token == "PrintObjectParents" || token == "pop") && (args.size() == 2)) {
0674                 PrintObjectParents(args[0], std::stoi(args[1]));
0675             }
0676             else if ((token == "PrintObjectAncestors" || token == "poa") && (args.size() == 2)) {
0677                 PrintObjectAncestors(args[0], std::stoi(args[1]));
0678             }
0679             else if (token == "ViewAsTable" || token == "vt") {
0680                 m_format = Format::Table;
0681                 m_out << "(Switching to table view mode)" << std::endl;
0682             }
0683             else if (token == "ViewAsJson" || token == "vj") {
0684                 m_format = Format::Json;
0685                 m_out << "(Switching to JSON view mode)" << std::endl;
0686             }
0687             else if (token == "Continue" || token == "c") {
0688                 stay_in_loop = false;
0689             }
0690             else if (token == "Exit" || token == "x") {
0691                 stay_in_loop = false;
0692             }
0693             else if (token == "Help" || token == "h") {
0694                 PrintHelp();
0695             }
0696             else if (token == "") {
0697                 // Do nothing
0698             }
0699             else {
0700                 m_out << "(Error: Unrecognized command, or wrong argument count)" << std::endl;
0701                 PrintHelp();
0702             }
0703 
0704         }
0705         catch (JException& ex) {
0706             m_out << "(JException: Maybe you tried to print out objects that are not JObjects)" << std::endl;
0707         }
0708         catch (std::invalid_argument&) {
0709             m_out << "(Parse error: Maybe an argument needs to be an int)" << std::endl;
0710         }
0711         catch (...) {
0712             m_out << "(Unknown error)" << std::endl;
0713         }
0714     }
0715 
0716     if (m_enable_ticker_on_exit) {
0717         m_event->GetJApplication()->SetTicker( true );
0718     }
0719     if (m_enable_timeout_on_exit) {
0720         m_event->GetJApplication()->SetTimeoutEnabled( true );
0721     }
0722 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!