renamed collection resolver producer related classes

source/orm/sql/internal/collection_resolver_producer.cpp

@@ -1,20 +0,0 @@
-#include "matador/sql/internal/collection_resolver_producer.hpp"
-
-namespace matador::sql {
-const std::type_index& collection_resolver_producer::root_type() const {
-  return root_type_;
-}
-
-const std::type_index& collection_resolver_producer::type() const {
-  return type_;
-}
-
-const std::string& collection_resolver_producer::collection_name() const {
-  return collection_name_;
-}
-
-collection_resolver_producer::collection_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)) {}
-}  // namespace matador::sql

source/orm/sql/internal/joined_collection_resolver_producer.cpp

@@ -0,0 +1,20 @@
+#include "matador/sql/internal/joined_collection_resolver_producer.hpp"
+
+namespace matador::sql {
+const std::type_index& joined_collection_resolver_producer::root_type() const {
+  return root_type_;
+}
+
+const std::type_index& joined_collection_resolver_producer::type() const {
+  return type_;
+}
+
+const std::string& joined_collection_resolver_producer::join_column_name() const {
+  return join_column_name_;
+}
+
+joined_collection_resolver_producer::joined_collection_resolver_producer(const std::type_index& root_type,
+                                                           const std::type_index& type,
+                                                           std::string join_column_name)
+: root_type_(root_type), type_(type), join_column_name_(std::move(join_column_name)) {}
+}  // namespace matador::sql

source/orm/sql/producer_object_resolver_factory.cpp

@@ -1,18 +1,18 @@
-#include "matador/sql/producer_resolver_factory.hpp"
+#include "matador/sql/producer_object_resolver_factory.hpp"
 
 namespace matador::sql {
-std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acquire_object_resolver(const std::type_index &type) const {
+std::shared_ptr<object::abstract_type_resolver> producer_object_resolver_factory::acquire_object_resolver(const std::type_index &type) const {
   if (const auto it = resolvers_.find(type); it != resolvers_.end()) {
     return it->second;
   }
   return nullptr;
 }
 
-void producer_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
+void producer_object_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
   resolvers_[resolver->type()] = std::move(resolver);
 }
 std::shared_ptr<object::abstract_joined_resolver>
-producer_collection_resolver_factory::acquire_collection_resolver(const std::type_index& root_type,
+producer_joined_collection_resolver_factory::acquire_collection_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};
@@ -21,7 +21,7 @@ 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_joined_resolver>&& resolver) {
+void producer_joined_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);
 }

source/orm/sql/resolver_service.cpp

@@ -6,7 +6,7 @@ void resolver_service::register_object_resolver(std::shared_ptr<object::abstract
 }
 
 void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
-  collection_resolver_factory_.register_collection_resolver(std::move(resolver));
+  joined_collection_resolver_factory_.register_collection_resolver(std::move(resolver));
 }
 
 void resolver_service::register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column) {