collection_resolver progress

include/matador/sql/internal/collection_resolver_producer.hpp

@@ -0,0 +1,28 @@
+#ifndef MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP
+#define MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP
+
+#include "matador/object/abstract_collection_resolver.hpp"
+
+#include <memory>
+
+namespace matador::sql {
+class executor;
+class collection_resolver_producer {
+public:
+  virtual ~collection_resolver_producer() = default;
+  virtual std::shared_ptr<object::abstract_collection_resolver> produce(executor &exec) = 0;
+
+  [[nodiscard]] const std::type_index& root_type() const;
+  [[nodiscard]] const std::type_index& type() const;
+  [[nodiscard]] const std::string& collection_name() const;
+
+protected:
+  explicit collection_resolver_producer(const std::type_index &root_type, const std::type_index &type, std::string collection_name);
+
+private:
+  std::type_index root_type_;
+  std::type_index type_;
+  std::string collection_name_;
+};
+}
+#endif  // MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP

include/matador/sql/internal/object_resolver_producer.hpp

@@ -1,7 +1,7 @@
 #ifndef MATADOR_RESOLVER_PRODUCER_HPP
 #define MATADOR_RESOLVER_PRODUCER_HPP
 
-#include "matador/object/object_resolver.hpp"
+#include "matador/object/abstract_type_resolver.hpp"
 
 #include <memory>
 

include/matador/sql/producer_resolver_factory.hpp

@@ -1,23 +1,60 @@
 #ifndef MATADOR_RESOLVER_FACTORY_HPP
 #define MATADOR_RESOLVER_FACTORY_HPP
 
-#include "matador/object/object_resolver_factory.hpp"
-
-#include "matador/sql/internal/object_resolver_producer.hpp"
-
 #include <unordered_map>
 
+#include "matador/object/abstract_collection_resolver.hpp"
+#include "matador/object/object_resolver_factory.hpp"
+#include "matador/sql/internal/object_resolver_producer.hpp"
+
 namespace matador::sql {
 class executor;
 
 class producer_resolver_factory : public object::object_resolver_factory {
 public:
-
   std::shared_ptr<object::abstract_type_resolver> acquire_object_resolver(const std::type_index &type) override;
   void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override;
 
 private:
   std::unordered_map<std::type_index, std::shared_ptr<object::abstract_type_resolver>> resolvers_;
 };
+
+struct composite_key {
+  std::type_index root_type;
+  std::type_index type;
+  std::string name;
+
+  bool operator==(const composite_key& other) const {
+    return root_type == other.root_type &&
+           type == other.type &&
+           name == other.name;
+  }
+};
+
+struct composite_key_hash {
+  std::size_t operator()(const composite_key& k) const noexcept {
+    const std::size_t h1 = std::hash<std::type_index>{}(k.root_type);
+    const std::size_t h2 = std::hash<std::type_index>{}(k.type);
+    const std::size_t h3 = std::hash<std::string>{}(k.name);
+
+    // Klassische Hash-Kombination (Boost-Style)
+    std::size_t seed = h1;
+    seed ^= h2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    seed ^= h3 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+
+    return seed;
+  }
+};
+
+class producer_collection_resolver_factory : public object::collection_resolver_factory {
+public:
+  std::shared_ptr<object::abstract_collection_resolver> acquire_collection_resolver(const std::type_index& root_type,
+                                                                                    const std::type_index& element_type,
+                                                                                    const std::string& collection_name) override;
+  void register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) override;
+
+private:
+  std::unordered_map<composite_key, std::shared_ptr<object::abstract_collection_resolver>, composite_key_hash> resolvers_;
+};
 }
 #endif //MATADOR_RESOLVER_FACTORY_HPP