has one progress

source/orm/sql/internal/object_resolver_producer.cpp

@@ -8,3 +8,20 @@ const std::type_index & object_resolver_producer::type() const {
 object_resolver_producer::object_resolver_producer(const std::type_index &type)
 : type_(type) {}
 }
+
+const std::type_index& matador::sql::joined_object_resolver_producer::root_type() const {
+  return root_type_;
+}
+
+const std::type_index& matador::sql::joined_object_resolver_producer::type() const {
+  return type_;
+}
+
+const std::string& matador::sql::joined_object_resolver_producer::collection_name() const {
+  return collection_name_;
+}
+
+matador::sql::joined_object_resolver_producer::joined_object_resolver_producer(const std::type_index& root_type,  const std::type_index& type, std::string collection_name)
+: root_type_(root_type)
+, type_(type)
+, collection_name_(std::move(collection_name)) {}

source/orm/sql/producer_resolver_factory.cpp

@@ -11,7 +11,7 @@ std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acqui
 void producer_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
   resolvers_[resolver->type()] = std::move(resolver);
 }
-std::shared_ptr<object::abstract_collection_resolver>
+std::shared_ptr<object::abstract_joined_resolver>
 producer_collection_resolver_factory::acquire_collection_resolver(const std::type_index& root_type,
                                                                   const std::type_index& element_type,
                                                                   const std::string& collection_name) const {
@@ -21,7 +21,22 @@ producer_collection_resolver_factory::acquire_collection_resolver(const std::typ
   }
   return nullptr;
 }
-void producer_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) {
+void producer_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
+  const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
+  resolvers_[key] = std::move(resolver);
+}
+
+std::shared_ptr<object::abstract_joined_resolver> producer_joined_object_resolver_factory::acquire_joined_object_resolver(const std::type_index& root_type,
+                                                                                                                          const std::type_index& element_type,
+                                                                                                                          const std::string& collection_name) const {
+  const object::collection_composite_key key{root_type, element_type, collection_name};
+  if (const auto it = resolvers_.find(key); it != resolvers_.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+void producer_joined_object_resolver_factory::register_joined_object_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
   const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
   resolvers_[key] = std::move(resolver);
 }

source/orm/sql/resolver_service.cpp

@@ -4,7 +4,12 @@ namespace matador::sql {
 void resolver_service::register_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver) {
   object_resolver_factory_.register_object_resolver(std::move(resolver));
 }
-void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) {
+
+void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
   collection_resolver_factory_.register_collection_resolver(std::move(resolver));
 }
+
+void resolver_service::register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver) {
+  joined_object_resolver_factory_.register_object_resolver(std::move(resolver));
+}
 }  // namespace matador::query