collection_resolver progress

source/orm/sql/connection.cpp

@@ -33,10 +33,10 @@ connection::connection(const connection_info& info, logger_ptr sql_logger)
 }
 
 connection::connection(const connection_info &info,
-                       std::shared_ptr<producer_resolver_factory> resolver_factory,
+                       const std::shared_ptr<resolver_service>& resolver,
                        logger_ptr sql_logger)
 : logger_(std::move(sql_logger))
-, resolver_factory_(std::move(resolver_factory)) {
+, resolver_service_(resolver) {
   connection_.reset(backend_provider::instance().create_connection(info.type, info));
 }
 
@@ -45,9 +45,9 @@ connection::connection(const std::string& dns, const logger_ptr &sql_logger)
 {}
 
 connection::connection(const std::string &dns,
-                       std::shared_ptr<producer_resolver_factory> resolver_factory,
+                       const std::shared_ptr<resolver_service> &resolver,
                        const logger_ptr &sql_logger)
-: connection(connection_info::parse(dns), std::move(resolver_factory), sql_logger)
+: connection(connection_info::parse(dns), std::move(resolver), sql_logger)
 {}
 
 connection::connection(const connection &x) {
@@ -70,13 +70,13 @@ connection &connection::operator=(const connection &x) {
 connection::connection( connection&& x ) noexcept
 : connection_(std::move(x.connection_))
 , logger_(std::move(x.logger_))
-, resolver_factory_(std::move(x.resolver_factory_))
+, resolver_service_(std::move(x.resolver_service_))
 {}
 
 connection & connection::operator=(connection &&x) noexcept {
   connection_  = std::move(x.connection_);
   logger_ = std::move(x.logger_);
-  resolver_factory_ = std::move(x.resolver_factory_);
+  resolver_service_ = std::move(x.resolver_service_);
 
   return *this;
 }
@@ -233,8 +233,8 @@ const class dialect &connection::dialect() const
   return connection_->dialect();
 }
 
-std::shared_ptr<class producer_resolver_factory> connection::resolver_factory() const {
-  return resolver_factory_;
+std::shared_ptr<resolver_service> connection::resolver() const {
+  return resolver_service_;
 }
 
 utils::result<std::unique_ptr<statement_impl>, utils::error> connection::perform_prepare(const query_context& ctx) const {

source/orm/sql/producer_resolver_factory.cpp

@@ -1,7 +1,7 @@
 #include "matador/sql/producer_resolver_factory.hpp"
 
 namespace matador::sql {
-std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acquire_object_resolver(const std::type_index &type) {
+std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acquire_object_resolver(const std::type_index &type) const {
   if (const auto it = resolvers_.find(type); it != resolvers_.end()) {
     return it->second;
   }
@@ -14,7 +14,7 @@ void producer_resolver_factory::register_object_resolver(std::shared_ptr<object:
 std::shared_ptr<object::abstract_collection_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 std::string& collection_name) const {
   const composite_key key{root_type, element_type, collection_name};
   if (const auto it = resolvers_.find(key); it != resolvers_.end()) {
     return it->second;

source/orm/sql/resolver_service.cpp

@@ -0,0 +1,10 @@
+#include "matador/sql/resolver_service.hpp"
+
+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) {
+  collection_resolver_factory_.register_collection_resolver(std::move(resolver));
+}
+}  // namespace matador::query