collection resolver progress

include/matador/object/abstract_type_resolver_factory.hpp

@@ -10,8 +10,8 @@ class abstract_type_resolver_factory {
 public:
   virtual ~abstract_type_resolver_factory() = default;
 
-  virtual std::shared_ptr<abstract_type_resolver> acquire_resolver(const std::type_index &type) = 0;
-  virtual void register_resolver(std::shared_ptr<abstract_type_resolver> &&resolver) = 0;
+  virtual std::shared_ptr<abstract_type_resolver> acquire_object_resolver(const std::type_index &type) = 0;
+  virtual void register_object_resolver(std::shared_ptr<abstract_type_resolver> &&resolver) = 0;
 };
 }
 #endif //MATADOR_ABSTRACT_TYPE_RESOLVER_FACTORY_HPP

include/matador/object/collection_proxy.hpp

@@ -12,19 +12,6 @@
 
 namespace matador::object {
 
-class abstract_collection_resolver {
-public:
-  virtual ~abstract_collection_resolver() = default;
-
-  [[nodiscard]] const std::type_index& type() const { return type_; }
-
-protected:
-  explicit abstract_collection_resolver(const std::type_index& ti) : type_(ti) {}
-
-public:
-  const std::type_index type_;
-};
-
 
 // template<typename Type>
 // class collection_resolver : public abstract_collection_resolver {

include/matador/object/collection_resolver.hpp

@@ -8,6 +8,19 @@
 #include <vector>
 
 namespace matador::object {
+class abstract_collection_resolver {
+public:
+  virtual ~abstract_collection_resolver() = default;
+
+  [[nodiscard]] const std::type_index& type() const { return type_; }
+
+protected:
+  explicit abstract_collection_resolver(const std::type_index& ti) : type_(ti) {}
+
+public:
+  const std::type_index type_;
+};
+
 template<typename Type>
 class collection_resolver : public abstract_type_resolver {
 public:

include/matador/object/collection_resolver_factory.hpp

@@ -5,11 +5,19 @@
 #include "matador/object/collection_resolver.hpp"
 
 namespace matador::object {
+class abstract_collection_resolver_factory {
+public:
+  virtual ~abstract_collection_resolver_factory() = default;
+
+  virtual std::shared_ptr<abstract_collection_resolver> acquire_collection_resolver(const std::type_index &root_type, const std::type_index &element_type, const std::string &collection_name) = 0;
+  virtual void register_collection_resolver(std::shared_ptr<abstract_collection_resolver> &&resolver) = 0;
+};
+
 class collection_resolver_factory : public abstract_type_resolver_factory {
 public:
   template<class Type>
   std::shared_ptr<collection_resolver<Type>> resolver() {
-    const auto res = acquire_resolver(typeid(std::vector<object_ptr<Type>>));
+    const auto res = acquire_object_resolver(typeid(std::vector<object_ptr<Type>>));
     if (!res) {
       return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
     }

include/matador/object/container_resolver.hpp

@@ -0,0 +1,23 @@
+#ifndef MATADOR_CONTAINER_RESOLVER_HPP
+#define MATADOR_CONTAINER_RESOLVER_HPP
+
+#include "matador/object/abstract_type_resolver.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace matador::utils {
+class identifier;
+}
+
+namespace matador::object {
+template<typename Type>
+class container_resolver : public abstract_type_resolver {
+public:
+  container_resolver() : abstract_type_resolver(typeid(Type)) {}
+
+  virtual std::shared_ptr<std::vector<Type>> resolve(const utils::identifier& id) = 0;
+};
+}
+
+#endif //MATADOR_CONTAINER_RESOLVER_HPP

include/matador/object/object_resolver.hpp

@@ -2,6 +2,7 @@
 #define MATADOR_OBJECT_LOADER_HPP
 
 #include "matador/object/abstract_type_resolver.hpp"
+
 #include <memory>
 
 namespace matador::utils {

include/matador/object/object_resolver_factory.hpp

@@ -10,23 +10,18 @@ class object_resolver_factory : public abstract_type_resolver_factory {
 public:
   template<class Type>
   std::shared_ptr<object_resolver<Type>> resolver() {
-    const auto res = acquire_resolver(std::type_index(typeid(Type)));
+    const auto res = acquire_object_resolver(std::type_index(typeid(Type)));
     if (!res) {
       return std::dynamic_pointer_cast<object_resolver<Type>>(res);
     }
 
     return std::dynamic_pointer_cast<object_resolver<Type>>(res);
   }
-  //
-  // template<class Type>
-  // std::shared_ptr<collection_resolver<Type>> collection_resolver(const std::string &name) {
-  //   const auto res = acquire_collection_resolver(std::type_index(typeid(Type)), name);
-  //   if (!res) {
-  //     return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
-  //   }
-  //
-  //   return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
-  // }
 };
+
+class object_resolver_service : public object_resolver_factory, public collection_resolver_factory {
+public:
+};
+
 }
 #endif //MATADOR_OBJECT_RESOLVER_FACTORY_HPP