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