Actually using the new product_query (Part 1)

.github/workflows/codeql-analysis.yaml

@@ -218,7 +218,13 @@ jobs:
           fi
 
   determine-languages:
-    needs: [pre-check, detect-changes-cpp, detect-changes-python, detect-changes-actions]
+    needs:
+      [
+        pre-check,
+        detect-changes-cpp,
+        detect-changes-python,
+        detect-changes-actions,
+      ]
     if: always() && needs.pre-check.result == 'success'
     runs-on: ubuntu-latest
     outputs:

form/form_module.cpp

@@ -63,7 +63,7 @@ namespace {
       auto segment_id = store.index()->to_string();
 
       std::cout << "\n=== FormOutputModule::save_data_products ===\n";
-      std::cout << "Creator: " << creator << "\n";
+      std::cout << "Creator: " << creator.full() << "\n";
       std::cout << "Segment ID: " << segment_id << "\n";
       std::cout << "Number of products: " << store.size() << "\n";
 
@@ -81,10 +81,10 @@ namespace {
         // product_ptr: pointer to the actual product data
         assert(product_ptr && "store should not contain null product_ptr");
 
-        std::cout << "  Product: " << product_name << "\n";
+        std::cout << "  Product: " << product_name.full() << "\n";
 
         // Create FORM product with metadata
-        products.emplace_back(product_name,           // label, from map key
+        products.emplace_back(product_name.name().trans_get_string(), // label, from map key
                               product_ptr->address(), // data,  from phlex product_base
                               &product_ptr->type()    // type, from phlex product_base
         );
@@ -95,7 +95,7 @@ namespace {
       // Write all products to FORM
       // Pass segment_id once for entire collection (not duplicated in each product)
       // No need to check if products is empty - already checked store.empty() above
-      m_form_interface->write(creator, segment_id, products);
+      m_form_interface->write(creator.full(), segment_id, products);
       std::cout << "Wrote " << products.size() << " products to FORM\n";
     }
 

phlex/core/consumer.cpp

@@ -8,8 +8,8 @@ namespace phlex::experimental {
 
   std::string consumer::full_name() const { return name_.full(); }
 
-  std::string const& consumer::plugin() const noexcept { return name_.plugin(); }
-  std::string const& consumer::algorithm() const noexcept { return name_.algorithm(); }
+  identifier const& consumer::plugin() const noexcept { return name_.plugin(); }
+  identifier const& consumer::algorithm() const noexcept { return name_.algorithm(); }
 
   std::vector<std::string> const& consumer::when() const noexcept { return predicates_; }
 }

phlex/core/consumer.hpp

@@ -12,8 +12,8 @@ namespace phlex::experimental {
     consumer(algorithm_name name, std::vector<std::string> predicates);
 
     std::string full_name() const;
-    std::string const& plugin() const noexcept;
-    std::string const& algorithm() const noexcept;
+    identifier const& plugin() const noexcept;
+    identifier const& algorithm() const noexcept;
     std::vector<std::string> const& when() const noexcept;
 
   private:

phlex/core/declared_fold.hpp

@@ -186,9 +186,9 @@ namespace phlex::experimental {
     {
       auto& result = results_.at(store->index()->hash());
       if constexpr (requires { send(*result); }) {
-        store->add_product(output()[0].name(), send(*result));
+        store->add_product(output()[0], send(*result));
       } else {
-        store->add_product(output()[0].name(), std::move(result));
+        store->add_product(output()[0], std::move(result));
       }
       // Reclaim some memory; it would be better to erase the entire entry from the map,
       // but that is not thread-safe.
@@ -198,7 +198,7 @@ namespace phlex::experimental {
     InitTuple initializer_;
     input_retriever_types<input_parameter_types> input_{input_arguments<input_parameter_types>()};
     product_specifications output_;
-    std::string partition_;
+    identifier partition_;
     tbb::flow::function_node<flush_message> flush_receiver_;
     join_or_none_t<num_inputs> join_;
     tbb::flow::multifunction_node<messages_t<num_inputs>, message_tuple<1>> fold_;

phlex/core/declared_provider.hpp

@@ -56,7 +56,9 @@ namespace phlex::experimental {
                   AlgorithmBits alg,
                   product_query output) :
       declared_provider{std::move(name), output},
-      output_{output.spec()},
+      output_{algorithm_name::create(std::string_view(identifier(output.creator))),
+              output.suffix.value_or(identifier("")),
+              output.type},
       provider_{g,
                 concurrency,
                 [this, ft = alg.release_algorithm()](index_message const& index_msg, auto& output) {
@@ -66,7 +68,7 @@ namespace phlex::experimental {
                   ++calls_;
 
                   products new_products;
-                  new_products.add(output_.name(), std::move(result));
+                  new_products.add(output_, std::move(result));
                   auto store = std::make_shared<product_store>(
                     index, this->full_name(), std::move(new_products));
 

phlex/core/declared_unfold.cpp

@@ -8,7 +8,7 @@
 namespace phlex::experimental {
 
   generator::generator(product_store_const_ptr const& parent,
-                       std::string node_name,
+                       algorithm_name node_name,
                        std::string const& child_layer_name) :
     parent_{std::const_pointer_cast<product_store>(parent)},
     node_name_{std::move(node_name)},

phlex/core/declared_unfold.hpp

@@ -10,6 +10,7 @@
 #include "phlex/model/algorithm_name.hpp"
 #include "phlex/model/data_cell_index.hpp"
 #include "phlex/model/handle.hpp"
+#include "phlex/model/identifier.hpp"
 #include "phlex/model/product_specification.hpp"
 #include "phlex/model/product_store.hpp"
 #include "phlex/utilities/simple_ptr_map.hpp"
@@ -34,7 +35,7 @@ namespace phlex::experimental {
   class generator {
   public:
     explicit generator(product_store_const_ptr const& parent,
-                       std::string node_name,
+                       algorithm_name node_name,
                        std::string const& child_layer_name);
     flush_counts_ptr flush_result() const;
 
@@ -47,7 +48,7 @@ namespace phlex::experimental {
   private:
     product_store_const_ptr make_child(std::size_t i, products new_products);
     product_store_ptr parent_;
-    std::string node_name_;
+    algorithm_name node_name_;
     std::string const& child_layer_name_;
     std::map<data_cell_index::hash_type, std::size_t> child_counts_;
   };

phlex/core/detail/filter_impl.cpp

@@ -76,7 +76,7 @@ namespace phlex::experimental {
 
     // Fill slots in the order of the input arguments to the downstream node.
     for (std::size_t i = 0; i != nargs_; ++i) {
-      if (elem[i] or not store->contains_product((*product_names_)[i].spec().full()))
+      if (elem[i] or not store->contains_product((*product_names_)[i].spec()))
         continue;
       elem[i] = store;
     }

phlex/core/detail/make_algorithm_name.cpp

@@ -1,10 +1,12 @@
 #include "phlex/core/detail/make_algorithm_name.hpp"
 #include "phlex/configuration.hpp"
 #include "phlex/model/algorithm_name.hpp"
+#include "phlex/model/identifier.hpp"
 
 namespace phlex::experimental::detail {
-  algorithm_name make_algorithm_name(configuration const* config, std::string name)
+  algorithm_name make_algorithm_name(configuration const* config, std::string_view name)
   {
-    return {config ? config->get<std::string>("module_label") : "", std::move(name)};
+    return {config ? identifier(config->get<std::string_view>("module_label")) : ""_id,
+            identifier(name)};
   }
 }

phlex/core/detail/make_algorithm_name.hpp

@@ -4,7 +4,7 @@
 // This simple utility is placed in an implementation file to avoid including the
 // phlex/configuration.hpp in framework code.
 
-#include <string>
+#include <string_view>
 
 namespace phlex {
   class configuration;
@@ -14,7 +14,7 @@ namespace phlex::experimental {
   class algorithm_name;
 
   namespace detail {
-    algorithm_name make_algorithm_name(configuration const* config, std::string name);
+    algorithm_name make_algorithm_name(configuration const* config, std::string_view name);
   }
 }
 

phlex/core/edge_creation_policy.cpp

@@ -10,7 +10,7 @@ namespace phlex::experimental {
     product_query const& query) const
   {
     // TODO: Update later with correct querying
-    auto [b, e] = producers_.equal_range(query.suffix.value_or(""_id).trans_get_string());
+    auto [b, e] = producers_.equal_range(query.suffix.value_or(""_id));
     if (b == e) {
       spdlog::debug(
         "Failed to find an algorithm that creates {} products. Assuming it comes from a provider",
@@ -19,9 +19,9 @@ namespace phlex::experimental {
     }
     std::map<std::string, named_output_port const*> candidates;
     for (auto const& [key, producer] : std::ranges::subrange{b, e}) {
-      // TODO: Definitely not right yet
-      if (producer.node.plugin() == std::string_view(identifier(query.creator)) ||
-          producer.node.algorithm() == std::string_view(identifier(query.creator))) {
+      // TODO: Getting there -- this whole thing needs to be replaced with something
+      //       that indexes all the fields from the beginning.
+      if (producer.node.plugin() == query.creator || producer.node.algorithm() == query.creator) {
         if (query.type != producer.type) {
           spdlog::debug("Matched ({}) from {} but types don't match (`{}` vs `{}`). Excluding "
                         "from candidate list.",

phlex/core/edge_creation_policy.hpp

@@ -2,6 +2,7 @@
 #define PHLEX_CORE_EDGE_CREATION_POLICY_HPP
 
 #include "phlex/core/message.hpp"
+#include "phlex/model/identifier.hpp"
 #include "phlex/model/product_specification.hpp"
 #include "phlex/model/type_id.hpp"
 
@@ -12,7 +13,7 @@
 #include <string>
 
 namespace phlex::experimental {
-  using product_name_t = std::string;
+  using product_name_t = identifier;
 
   class edge_creation_policy {
   public:
@@ -44,7 +45,7 @@ namespace phlex::experimental {
     std::multimap<product_name_t, named_output_port> result;
     for (auto const& [node_name, node] : nodes) {
       for (auto const& product_name : node->output()) {
-        if (empty(product_name.name()))
+        if (product_name.name().empty())
           continue;
 
         result.emplace(product_name.name(),

phlex/core/edge_maker.hpp

@@ -23,7 +23,7 @@
 namespace phlex::experimental {
   using namespace std::string_literals;
 
-  using product_name_t = std::string;
+  using product_name_t = identifier;
 
   index_router::provider_input_ports_t make_provider_edges(index_router::head_ports_t head_ports,
                                                            declared_providers& providers);

phlex/core/index_router.cpp

@@ -89,16 +89,15 @@ namespace phlex::experimental {
   void detail::multilayer_slot::put_message(data_cell_index_ptr const& index,
                                             std::size_t message_id)
   {
-    auto const layer = static_cast<std::string_view>(layer_);
-    if (layer == index->layer_name()) {
+    if (layer_ == index->layer_name()) {
       broadcaster_.try_put({.index = index, .msg_id = message_id, .cache = false});
       return;
     }
 
     // Flush values are only used for indices that are *not* the "lowest" in the branch
     // of the hierarchy.
     ++counter_;
-    broadcaster_.try_put({.index = index->parent(layer), .msg_id = message_id});
+    broadcaster_.try_put({.index = index->parent(layer_), .msg_id = message_id});
   }
 
   void detail::multilayer_slot::put_end_token(data_cell_index_ptr const& index)
@@ -119,7 +118,7 @@ namespace phlex::experimental {
 
   bool detail::multilayer_slot::is_parent_of(data_cell_index_ptr const& index) const
   {
-    return index->parent(static_cast<std::string_view>(layer_)) != nullptr;
+    return index->parent(layer_) != nullptr;
   }
 
   //========================================================================================
@@ -197,7 +196,8 @@ namespace phlex::experimental {
       return;
     }
 
-    auto broadcaster = index_node_for(index->layer_name());
+    std::string const layerish_path{static_cast<std::string_view>(index->layer_name())};
+    auto broadcaster = index_node_for(layerish_path);
     if (broadcaster) {
       broadcaster->try_put({.index = index, .msg_id = message_id});
     }

phlex/core/input_arguments.hpp

@@ -5,7 +5,11 @@
 #include "phlex/core/product_query.hpp"
 #include "phlex/model/handle.hpp"
 
+#include "fmt/format.h"
+
+#include <algorithm>
 #include <cstddef>
+#include <ranges>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -18,7 +22,30 @@
     product_query query;
     auto retrieve(message const& msg) const
     {
-      return msg.store->get_handle<handle_arg_t>(query.spec().name());
+      namespace views = std::ranges::views;
+      auto const& store = msg.store;
+      // TODO: This needs to be replaced with a properly engineered solution
+      auto all_products = std::ranges::subrange(store->begin(), store->end()) | views::keys;
+      auto products =
+        all_products |
+        views::filter([this](product_specification const& spec) { return query.match(spec); }) |
+        views::transform([](product_specification const& spec) { return std::cref(spec); }) |
+        std::ranges::to<std::vector>();
+      if (products.empty()) {
+        throw std::runtime_error(fmt::format(
+          "No products found matching the query {}\n Store (id {} from {}) contains:\n    - {}",
+          query,
+          store->index()->to_string(),
+          store->source().full(),
+          fmt::join(all_products | views::transform(&product_specification::full), "\n    - ")));
+      }
+      if (products.size() > 1) {
+        throw std::runtime_error(fmt::format(
+          "Multiple products found matching the query {}:\n    - {}",
+          query,
+          fmt::join(products | views::transform(&product_specification::full), "\n    - ")));
+      }
+      return store->get_handle<handle_arg_t>(products[0]);
     }
   };
 

phlex/core/message.cpp

@@ -1,6 +1,8 @@
 #include "phlex/core/message.hpp"
 #include "phlex/model/data_cell_index.hpp"
 
+#include "fmt/format.h"
+
 #include <algorithm>
 #include <iterator>
 #include <stdexcept>
@@ -26,8 +28,8 @@
     auto const [b, e] = std::tuple{cbegin(product_labels), cend(product_labels)};
     auto it = std::find(b, e, product_label);
     if (it == e) {
-      throw std::runtime_error("Algorithm does not accept product '" + product_label.spec().name() +
-                               "'.");
+      throw std::runtime_error(
+        fmt::format("Algorithm does not accept product '{}'.", product_label));
     }
     return std::distance(b, it);
   }

phlex/core/product_query.cpp

@@ -29,15 +29,15 @@ namespace phlex {
   // Check if a product_specification satisfies this query
   bool product_query::match(experimental::product_specification const& spec) const
   {
-    // string comparisons for now for a gradual transition
-    if (std::string_view(experimental::identifier(creator)) != spec.algorithm()) {
+    experimental::identifier tmp_creator{this->creator};
+    if (tmp_creator != spec.algorithm() && tmp_creator != spec.plugin()) {
       return false;
     }
     if (type != spec.type()) {
       return false;
     }
     if (suffix) {
-      if (std::string_view(*suffix) != spec.name()) {
+      if (*suffix != spec.name()) {
         return false;
       }
     }
@@ -58,8 +58,12 @@ namespace phlex {
       throw std::logic_error("Product suffixes are (temporarily) mandatory");
     }
     // Not efficient, but this should be temporary
-    return experimental::product_specification::create(suffix->trans_get_string());
+    using namespace phlex::experimental;
+    auto const& creator_identifier = static_cast<experimental::identifier const&>(creator);
+    return product_specification{
+      algorithm_name::create(static_cast<std::string_view>(creator_identifier)), *suffix, type};
   }
+
   bool product_query::operator==(product_query const& rhs) const
   {
     using experimental::identifier;

phlex/core/product_query.hpp

@@ -82,6 +82,7 @@
     experimental::product_specification spec() const;
   };
 
+  inline std::string format_as(product_query const& q) { return q.to_string(); }
   using product_queries = std::vector<product_query>;
   namespace detail {
     // C is a container of product_queries