JANA/Components/JOmniFactoryGeneratorT.h

0001 // Copyright 2023, Jefferson Science Associates, LLC.
0002 // Subject to the terms in the LICENSE file found in the top-level directory.
0003 // Created by Nathan Brei
0004
0005 #pragma once
0006
0007 #include <JANA/JFactorySet.h>
0008 #include <JANA/JFactoryGenerator.h>
0009 #include <vector>
0010
0011 namespace jana::components {
0012
0013 template<class FactoryT>
0014 class JOmniFactoryGeneratorT : public JFactoryGenerator {
0015 public:
0016     using FactoryConfigType = typename FactoryT::ConfigType;
0017
0018     struct TypedWiring {
0019         std::string tag = "";
0020         JEventLevel level = JEventLevel::PhysicsEvent;
0021         std::vector<std::string> input_names = {};
0022         std::vector<JEventLevel> input_levels = {};
0023         std::vector<std::vector<std::string>> variadic_input_names = {};
0024         std::vector<JEventLevel> variadic_input_levels = {};
0025         std::vector<std::string> output_names = {};
0026         std::vector<std::vector<std::string>> variadic_output_names = {};
0027         FactoryConfigType configs = {}; /// Must be copyable!
0028     };
0029
0030 public:
0031
0032     explicit JOmniFactoryGeneratorT() = default;
0033
0034     explicit JOmniFactoryGeneratorT(std::string tag,
0035                                     std::vector<std::string> input_names,
0036                                     std::vector<std::string> output_names,
0037                                     FactoryConfigType configs) {
0038         m_typed_wirings.push_back({.tag=tag,
0039                                    .input_names=input_names,
0040                                    .output_names=output_names,
0041                                    .configs=configs
0042                                   });
0043     };
0044
0045     explicit JOmniFactoryGeneratorT(std::string tag,
0046                                     std::vector<std::string> input_names,
0047                                     std::vector<std::string> output_names) {
0048         m_typed_wirings.push_back({.tag=tag,
0049                                    .input_names=input_names,
0050                                    .output_names=output_names
0051                                   });
0052
0053     }
0054
0055     explicit JOmniFactoryGeneratorT(TypedWiring&& wiring) {
0056         m_typed_wirings.push_back(std::move(wiring));
0057     }
0058
0059
0060     void AddWiring(std::string tag,
0061                    std::vector<std::string> input_names,
0062                    std::vector<std::string> output_names,
0063                    FactoryConfigType configs={}) {
0064
0065         m_typed_wirings.push_back({.tag=tag,
0066                                    .input_names=input_names,
0067                                    .output_names=output_names,
0068                                    .configs=configs
0069                                   });
0070     }
0071
0072
0073     void AddWiring(TypedWiring wiring) {
0074         m_typed_wirings.push_back(wiring);
0075     }
0076
0077     void GenerateFactories(JFactorySet *factory_set) override {
0078
0079         if (m_typed_wirings.size() == 0) {
0080             FactoryT *factory = new FactoryT;
0081             factory->SetPluginName(this->GetPluginName());
0082             factory->SetTypeName(JTypeInfo::demangle<FactoryT>());
0083             factory->Wire(GetApplication());
0084             factory_set->Add(factory);
0085         }
0086
0087         for (auto& wiring : m_typed_wirings) {
0088
0089             auto prefix = (GetPluginName().empty()) ? wiring.tag : this->GetPluginName() + ":" + wiring.tag;
0090             GetApplication()->SetDefaultParameter(prefix + ":InputTags", wiring.input_names, "Input collection names");
0091             GetApplication()->SetDefaultParameter(prefix + ":OutputTags", wiring.output_names, "Output collection names");
0092
0093             FactoryT *factory = new FactoryT;
0094             factory->SetPluginName(this->GetPluginName());
0095             factory->SetTypeName(JTypeInfo::demangle<FactoryT>());
0096             factory->SetPrefix(prefix);
0097
0098             // Apply the wiring information passed to the generator
0099             factory->SetLevel(wiring.level);
0100             factory->WireInputs(wiring.level, wiring.input_levels, wiring.input_names, wiring.variadic_input_levels, wiring.variadic_input_names);
0101             factory->WireOutputs(wiring.level, wiring.output_names, wiring.variadic_output_names, false);
0102             factory->config() = wiring.configs;
0103
0104             // Apply the wiring information from file
0105             factory->Wire(GetApplication());
0106
0107             // Factory is ready
0108             factory_set->Add(factory);
0109         }
0110     }
0111
0112 private:
0113     std::vector<TypedWiring> m_typed_wirings;
0114 };
0115
0116 } // namespace jana::components
0117 using jana::components::JOmniFactoryGeneratorT;