Reestablish compatibility with EICrecon's JOmniFactory

Author: nathanwbrei

src/libraries/JANA/Components/JHasInputs.h

@@ -20,13 +20,16 @@ struct JHasInputs {
 
     std::vector<InputBase*> m_inputs;
     std::vector<VariadicInputBase*> m_variadic_inputs;
+    std::vector<std::pair<InputBase*, VariadicInputBase*>> m_ordered_inputs;
 
     void RegisterInput(InputBase* input) {
         m_inputs.push_back(input);
+        m_ordered_inputs.push_back({input, nullptr});
     }
 
     void RegisterInput(VariadicInputBase* input) {
         m_variadic_inputs.push_back(input);
+        m_ordered_inputs.push_back({nullptr, input});
     }
 
     struct InputOptions {
@@ -465,6 +468,11 @@ struct JHasInputs {
                     const std::vector<JEventLevel>& variadic_input_levels,
                     const std::vector<std::vector<std::string>>& variadic_input_databundle_names) {
 
+        if (m_variadic_inputs.size() == 1 && variadic_input_databundle_names.size() == 0) {
+            WireInputsCompatibility(component_level, single_input_levels, single_input_databundle_names);
+            return;
+        }
+
         // Validate that we have the correct number of input databundle names
         if (single_input_databundle_names.size() != m_inputs.size()) {
             throw JException("Wrong number of (nonvariadic) input databundle names! Expected %d, found %d", m_inputs.size(), single_input_databundle_names.size());
@@ -499,6 +507,45 @@ struct JHasInputs {
         }
     }
 
+    void WireInputsCompatibility(JEventLevel component_level,
+                    const std::vector<JEventLevel>& single_input_levels,
+                    const std::vector<std::string>& single_input_databundle_names) {
+
+        // Figure out how many collection names belong to the variadic input
+        int variadic_databundle_count = single_input_databundle_names.size() - m_inputs.size();
+        int databundle_name_index = 0;
+        int databundle_level_index = 0;
+
+        for (auto& [single_input, variadic_input] : m_ordered_inputs) {
+            if (single_input != nullptr) {
+                single_input->SetDatabundleName(single_input_databundle_names.at(databundle_name_index));
+                if (single_input_levels.empty()) {
+                    single_input->SetLevel(component_level);
+                }
+                else {
+                    single_input->SetLevel(single_input_levels.at(databundle_level_index));
+                }
+                databundle_name_index += 1;
+                databundle_level_index += 1;
+            }
+            else {
+                std::vector<std::string> variadic_databundle_names;
+                for (int i=0; i<variadic_databundle_count; ++i) {
+                    variadic_databundle_names.push_back(single_input_databundle_names.at(databundle_name_index+i));
+                }
+                variadic_input->SetRequestedDatabundleNames(variadic_databundle_names);
+                if (single_input_levels.empty()) {
+                    variadic_input->SetLevel(component_level);
+                }
+                else {
+                    variadic_input->SetLevel(single_input_levels.at(databundle_level_index)); // Last one wins!
+                }
+                databundle_name_index += variadic_databundle_count;
+                databundle_level_index += 1;
+            }
+        }
+    }
+
     void SummarizeInputs(JComponentSummary::Component& summary) const {
         for (const auto* input : m_inputs) {
             summary.AddInput(new JComponentSummary::Collection("", input->GetDatabundleName(), input->GetTypeName(), input->GetLevel()));

src/libraries/JANA/Components/JHasOutputs.h

@@ -61,7 +61,7 @@ struct JHasOutputs {
     protected:
 
         void CreateHelperFactory(JMultifactory& fac) override {
-            fac.DeclareOutput<T>(this->collection_names[0]);
+            fac.DeclareOutput<T>(this->collection_names[0], !is_not_owner);
         }
 
         void SetCollection(JMultifactory& fac) override {
@@ -188,14 +188,45 @@ struct JHasOutputs {
         size_t single_output_index = 0;
         size_t variadic_output_index = 0;
 
+        size_t variadic_output_count = 0;
         for (auto* output : m_outputs) {
-            output->collection_names.clear();
-            output->level = component_level;
             if (output->is_variadic) {
-                output->collection_names = variadic_output_databundle_names.at(variadic_output_index++);
+                variadic_output_count += 1;
             }
-            else {
-                output->collection_names.push_back(single_output_databundle_names.at(single_output_index++));
+        }
+        if (variadic_output_count == 1 && variadic_output_databundle_names.size() == 0) {
+            // Obtain variadic databundle names from excess single-output databundle names
+            int variadic_databundle_count = single_output_databundle_names.size() - m_outputs.size() + 1;
+            int current_databundle_index = 0;
+
+            for (auto* output : m_outputs) {
+                output->collection_names.clear();
+                output->level = component_level;
+                if (output->is_variadic) {
+                    std::vector<std::string> variadic_names;
+                    for (int i=0; i<variadic_databundle_count; ++i) {
+                        variadic_names.push_back(single_output_databundle_names.at(current_databundle_index+i));
+                    }
+                    output->collection_names = variadic_names;
+                    current_databundle_index += variadic_databundle_count;
+                }
+                else {
+                    output->collection_names.push_back(single_output_databundle_names.at(current_databundle_index));
+                    current_databundle_index += 1;
+                }
+            }
+        }
+        else {
+            // Do the obvious, sensible thing instead
+            for (auto* output : m_outputs) {
+                output->collection_names.clear();
+                output->level = component_level;
+                if (output->is_variadic) {
+                    output->collection_names = variadic_output_databundle_names.at(variadic_output_index++);
+                }
+                else {
+                    output->collection_names.push_back(single_output_databundle_names.at(single_output_index++));
+                }
             }
         }
     }

src/programs/unit_tests/Components/JOmniFactoryTests.cc

@@ -38,12 +38,14 @@ struct MyFac : public JOmniFactory<MyFac> {
         }
 
         podio_hits_out()->setSubsetCollection();
+        variadic_podio_hits_out().at(0)->setSubsetCollection();
+
         for (auto hit : *podio_hits_in) {
             podio_hits_out()->push_back(hit);
             variadic_podio_hits_out().at(0)->push_back(hit);
         }
 
-        variadic_podio_hits_out().at(1)->push_back(ExampleHit(22, 1.1, 1.1, 1.1, 10, 0));
+        variadic_podio_hits_out().at(1)->push_back(MutableExampleHit(22, 1.1, 1.1, 1.1, 10, 0));
     }
 };