added collection, collection proxy and collection resolver implementations

include/matador/object/abstract_type_resolver.hpp

@@ -0,0 +1,20 @@
+#ifndef MATADOR_ABSTRACT_TYPE_RESOLVER_HPP
+#define MATADOR_ABSTRACT_TYPE_RESOLVER_HPP
+
+#include <typeindex>
+
+namespace matador::object {
+class abstract_type_resolver {
+public:
+  virtual ~abstract_type_resolver() = default;
+
+  [[nodiscard]] const std::type_index& type() const { return type_; }
+
+protected:
+  explicit abstract_type_resolver(const std::type_index& ti) : type_(ti) {}
+
+public:
+  const std::type_index type_;
+};
+}
+#endif //MATADOR_ABSTRACT_TYPE_RESOLVER_HPP

include/matador/object/abstract_type_resolver_factory.hpp

@@ -0,0 +1,17 @@
+#ifndef MATADOR_ABSTRACT_TYPE_RESOLVER_FACTORY_HPP
+#define MATADOR_ABSTRACT_TYPE_RESOLVER_FACTORY_HPP
+
+#include "matador/object/abstract_type_resolver.hpp"
+
+#include <memory>
+
+namespace matador::object {
+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;
+};
+}
+#endif //MATADOR_ABSTRACT_TYPE_RESOLVER_FACTORY_HPP

include/matador/object/collection.hpp

@@ -1,7 +1,7 @@
 #ifndef COLLECTION_HPP
 #define COLLECTION_HPP
 
-#include <vector>
+#include "matador/object/collection_proxy.hpp"
 
 namespace matador::object {
 
@@ -9,12 +9,43 @@ template < class Type >
 class collection {
 public:
   using value_type = Type;
+  using iterator = typename std::vector<value_type>::iterator;
+  using const_iterator = typename std::vector<value_type>::const_iterator;
 
-  void push_back(const Type& value) { data_.push_back(value); }
+  void push_back(const value_type& value) {
+    proxy_->items().push_back(value);
+  }
+
+  iterator begin() {
+    return proxy_->items().begin();
+  }
+
+  iterator end() {
+    return proxy_->items().end();
+  }
+
+  const_iterator begin() const {
+    return proxy_->items().begin();
+  }
+
+  const_iterator end() const {
+    return proxy_->items().end();
+  }
+
+  [[nodiscard]] size_t size() const {
+    return proxy_->items().size();
+  }
+
+  [[nodiscard]] bool empty() const {
+    return proxy_->items_.empty();
+  }
+
+  void reset(std::shared_ptr<collection_proxy<typename Type::value_type>> proxy) {
+    proxy_ = std::move(proxy);
+  }
 
-  [[nodiscard]] size_t size() const { return data_.size(); }
 private:
-  std::vector<Type> data_;
+  std::shared_ptr<collection_proxy<typename Type::value_type>> proxy_;
 };
 
 }

include/matador/object/collection_proxy.hpp

@@ -0,0 +1,82 @@
+#ifndef MATADOR_COLLECTION_PROXY_HPP
+#define MATADOR_COLLECTION_PROXY_HPP
+
+#include <atomic>
+
+#include "matador/object/object_ptr.hpp"
+
+#include "matador/utils/identifier.hpp"
+
+#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_collection_resolver {
+public:
+  collection_resolver() : abstract_collection_resolver(typeid(Type)) {}
+
+  virtual std::shared_ptr<Type> resolve(const utils::identifier& id) = 0;
+};
+
+template<typename Type>
+class collection_proxy final {
+public:
+  collection_proxy(std::weak_ptr<object_resolver<Type>> resolver, utils::identifier owner_id)
+  : owner_id_(std::move(owner_id)), resolver_(std::move(resolver)) {}
+
+  collection_proxy(std::weak_ptr<object_resolver<Type>> resolver, std::vector<object_ptr<Type>> items)
+  : items_(std::move(items)), resolver_(std::move(resolver)) {}
+
+  explicit collection_proxy(std::vector<object_ptr<Type>> items)
+  : items_(std::move(items)) {}
+
+  [[nodiscard]] const utils::identifier& owner_id() const {
+    return owner_id_;
+  }
+  const std::vector<object_ptr<Type>>& items() const {
+    return items_;
+  }
+  std::vector<object_ptr<Type>>& items() {
+    return items_;
+  }
+private:
+  void resolve() const {
+    if (loaded_) {
+      return;
+    }
+
+    std::lock_guard lock(mutex_);
+    auto resolver = resolver_.lock();
+    if (!resolver) {
+      return;
+      // Todo: Add states (Detached, Attached, Transient) - if attached an no resolver is available throw runtime exception
+      // throw std::runtime_error("Detached proxy (session expired)");
+    }
+
+    items_ = resolver->resolve(owner_id_);
+  }
+
+private:
+  const utils::identifier owner_id_;
+  std::atomic_bool loaded_{false};
+  std::vector<object_ptr<Type>> items_;
+  std::weak_ptr<object_resolver<Type>> resolver_{};
+  mutable std::mutex mutex_{};
+};
+}
+#endif //MATADOR_COLLECTION_PROXY_HPP

include/matador/object/collection_resolver.hpp

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

include/matador/object/collection_resolver_factory.hpp

@@ -0,0 +1,21 @@
+#ifndef MATADOR_CONTAINER_RESOLVER_FACTORY_HPP
+#define MATADOR_CONTAINER_RESOLVER_FACTORY_HPP
+
+#include "matador/object/abstract_type_resolver_factory.hpp"
+#include "matador/object/collection_resolver.hpp"
+
+namespace matador::object {
+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>>));
+    if (!res) {
+      return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
+    }
+
+    return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
+  }
+};
+}
+#endif //MATADOR_CONTAINER_RESOLVER_FACTORY_HPP

include/matador/object/object_resolver.hpp

@@ -1,33 +1,18 @@
 #ifndef MATADOR_OBJECT_LOADER_HPP
 #define MATADOR_OBJECT_LOADER_HPP
 
+#include "matador/object/abstract_type_resolver.hpp"
 #include <memory>
-#include <typeindex>
 
 namespace matador::utils {
 class identifier;
 }
 
 namespace matador::object {
-
-class abstract_object_resolver {
-public:
-  virtual ~abstract_object_resolver() = default;
-
-  [[nodiscard]] const std::type_index& type() const { return type_; }
-
-protected:
-  explicit abstract_object_resolver(const std::type_index& ti) : type_(ti) {}
-
-public:
-  const std::type_index type_;
-};
-
-
 template<typename Type>
-class object_resolver : public abstract_object_resolver {
+class object_resolver : public abstract_type_resolver {
 public:
-  object_resolver() : abstract_object_resolver(typeid(Type)) {}
+  object_resolver() : abstract_type_resolver(typeid(Type)) {}
 
   virtual std::shared_ptr<Type> resolve(const utils::identifier& id) = 0;
 };

include/matador/object/object_resolver_factory.hpp

@@ -1,15 +1,12 @@
 #ifndef MATADOR_OBJECT_RESOLVER_FACTORY_HPP
 #define MATADOR_OBJECT_RESOLVER_FACTORY_HPP
 
+#include "matador/object/abstract_type_resolver_factory.hpp"
 #include "matador/object/object_resolver.hpp"
 
-#include <unordered_map>
-
 namespace matador::object {
-class object_resolver_factory {
+class object_resolver_factory : public abstract_type_resolver_factory {
 public:
-  virtual ~object_resolver_factory() = default;
-
   template<class Type>
   std::shared_ptr<object_resolver<Type>> resolver() {
     const auto res = acquire_resolver(std::type_index(typeid(Type)));
@@ -19,9 +16,6 @@ public:
 
     return std::dynamic_pointer_cast<object_resolver<Type>>(res);
   }
-
-  virtual std::shared_ptr<abstract_object_resolver> acquire_resolver(const std::type_index &type) = 0;
-  virtual void register_resolver(std::shared_ptr<abstract_object_resolver> &&resolver) = 0;
 };
 }
 #endif //MATADOR_OBJECT_RESOLVER_FACTORY_HPP

include/matador/query/schema.hpp

@@ -27,7 +27,7 @@ public:
   , table_(tab)
   , pk_name_(std::move(pk_name)) {}
 
-  std::shared_ptr<object::abstract_object_resolver> produce(sql::executor &exec) override {
+  std::shared_ptr<object::abstract_type_resolver> produce(sql::executor &exec) override {
     return std::make_shared<query_object_resolver<Type>>(repo_, exec, table_, std::move(pk_name_));
   }
 

include/matador/sql/internal/query_result_impl.hpp

@@ -129,6 +129,7 @@ public:
     auto resolver = resolver_factory_->resolver<value_type>();
 
     if (attr.fetch() == utils::fetch_type::Lazy) {
+
       // pk_reader_.read(*id, column_index_++);
     } else {
       const auto ti = std::type_index(typeid(value_type));

include/matador/sql/internal/resolver_producer.hpp

@@ -10,7 +10,7 @@ class executor;
 class resolver_producer {
 public:
   virtual ~resolver_producer() = default;
-  virtual std::shared_ptr<object::abstract_object_resolver> produce(executor &exec) = 0;
+  virtual std::shared_ptr<object::abstract_type_resolver> produce(executor &exec) = 0;
 
   [[nodiscard]] const std::type_index& type() const;
 

include/matador/sql/producer_resolver_factory.hpp

@@ -5,17 +5,19 @@
 
 #include "matador/sql/internal/resolver_producer.hpp"
 
+#include <unordered_map>
+
 namespace matador::sql {
 class executor;
 
 class producer_resolver_factory : public object::object_resolver_factory {
 public:
 
-  std::shared_ptr<object::abstract_object_resolver> acquire_resolver(const std::type_index &type) override;
+  std::shared_ptr<object::abstract_type_resolver> acquire_resolver(const std::type_index &type) override;
-  void register_resolver(std::shared_ptr<object::abstract_object_resolver> &&resolver) override;
+  void register_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override;
 
 private:
-  std::unordered_map<std::type_index, std::shared_ptr<object::abstract_object_resolver>> resolvers_;
+  std::unordered_map<std::type_index, std::shared_ptr<object::abstract_type_resolver>> resolvers_;
 };
 }
 #endif //MATADOR_RESOLVER_FACTORY_HPP

source/core/CMakeLists.txt

@@ -113,6 +113,11 @@ add_library(matador-core STATIC
   utils/uuid.cpp
   utils/value.cpp
   utils/version.cpp
+  ../../include/matador/object/collection_proxy.hpp
+  ../../include/matador/object/collection_resolver_factory.hpp
+  ../../include/matador/object/collection_resolver.hpp
+  ../../include/matador/object/abstract_type_resolver.hpp
+  ../../include/matador/object/abstract_type_resolver_factory.hpp
 )
 
 target_link_libraries(matador-core ${CMAKE_DL_LIBS})

source/orm/sql/producer_resolver_factory.cpp

@@ -1,14 +1,14 @@
 #include "matador/sql/producer_resolver_factory.hpp"
 
 namespace matador::sql {
-std::shared_ptr<object::abstract_object_resolver> producer_resolver_factory::acquire_resolver(const std::type_index &type) {
+std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acquire_resolver(const std::type_index &type) {
   if (const auto it = resolvers_.find(type); it != resolvers_.end()) {
     return it->second;
   }
   return nullptr;
 }
 
-void producer_resolver_factory::register_resolver(std::shared_ptr<object::abstract_object_resolver> &&resolver) {
+void producer_resolver_factory::register_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
   resolvers_[resolver->type()] = std::move(resolver);
 }
 }

test/backends/QueryTest.cpp

@@ -636,13 +636,6 @@ TEST_CASE_METHOD(QueryFixture, "Test load entity with lazy belongs to relation",
   REQUIRE(count.is_ok());
   REQUIRE(*count == 5);
 
-  // auto emps_result = query::select({EMPLOYEE.id, EMPLOYEE.first_name, EMPLOYEE.last_name, DEPARTMENT.id, DEPARTMENT.name})
-  //   .from(EMPLOYEE)
-  //   .join_left(DEPARTMENT)
-  //   .on(EMPLOYEE.dep_id == DEPARTMENT.id)
-  //   .order_by(EMPLOYEE.id).asc()
-  //   .fetch_all<employee>(db);
-
   auto emps_result = query::select({EMPLOYEE.id, EMPLOYEE.first_name, EMPLOYEE.last_name, EMPLOYEE.dep_id})
     .from(EMPLOYEE)
     .order_by(EMPLOYEE.id).asc()