implemented lazy loading for object_ptr and belongs_to

include/matador/object/object_proxy.hpp

@@ -3,92 +3,76 @@
 
 #include "matador/object/primary_key_resolver.hpp"
 
+#include "matador/object/object_resolver.hpp"
+
 #include <memory>
+#include <utility>
+#include <stdexcept>
+#include <mutex>
 
 namespace matador::object {
-
-class basic_object_proxy {
-public:
-    virtual ~basic_object_proxy() = default;
-
-    [[nodiscard]] virtual void *get() const = 0;
-};
-
-template < typename Type >
-class object_proxy;
-
-template < typename Type >
-class object_resolver {
-public:
-    virtual ~object_resolver() = default;
-
-    virtual Type* resolve(const object_proxy<Type> &proxy) const = 0;
-};
-
-template < typename Type >
-class static_object_resolver final : public object_resolver<Type> {
-public:
-    static_object_resolver() = default;
-    explicit static_object_resolver(Type* obj)
-    : obj_(obj) {}
-    explicit static_object_resolver(std::unique_ptr<Type> obj)
-    : obj_(std::move(obj)) {}
-
-    Type* resolve(const object_proxy<Type> &/*proxy*/) const override {
-        return obj_.get();
-    }
-
-private:
-    std::unique_ptr<Type> obj_{};
-};
-
-
 template<class Type>
-class object_proxy final : public basic_object_proxy {
+class object_proxy final {
 public:
   object_proxy() = default;
-  explicit object_proxy(Type* obj)
-  : resolver_(std::make_unique<static_object_resolver<Type>>(obj))
-  , pk_(primary_key_resolver::resolve_object(*obj).pk) {}
 
-  [[nodiscard]] void *get() const override { return static_cast<void*>(pointer()); }
-
-  Type* operator->() const { return pointer(); }
-  Type& operator*() { return *pointer(); }
-  const Type& operator*() const { return *pointer(); }
-
-  Type* pointer() const { return resolve(); }
-
-  Type& ref() { return *pointer(); }
-  const Type& ref() const { return *pointer(); }
-
-  void reset(Type* obj) {
-    pk_ = primary_key_resolver::resolve_object(*obj).pk;
-    resolver_ = std::make_unique<static_object_resolver<Type>>(obj);
+  // Lazy
+  object_proxy(std::weak_ptr<object_resolver<Type>> resolver, utils::identifier id)
+  : resolver_(resolver)
+  , pk_(std::move(id)) {
   }
-  void reset(std::unique_ptr<Type> obj) {
-    pk_ = primary_key_resolver::resolve_object(*obj).pk;
-    resolver_ = std::make_unique<static_object_resolver<Type>>(std::move(obj));
+
+  // Eager
+  object_proxy(std::weak_ptr<object_resolver<Type>> resolver, std::shared_ptr<Type> obj)
+  : obj_(obj)
+  , resolver_(resolver)
+  , pk_(primary_key_resolver::resolve_object(*obj).pk) {
   }
-  void reset(std::unique_ptr<object_resolver<Type>> &&resolver) {
-    resolver_ = std::move(resolver);
+
+  // Transient
+  explicit object_proxy(std::shared_ptr<Type> obj)
+  : obj_(obj)
+  , pk_(primary_key_resolver::resolve_object(*obj).pk) {
   }
 
+  [[nodiscard]] void *raw_pointer() const { return static_cast<void *>(pointer()); }
+
+  Type *operator->() { return pointer(); }
+  Type &operator*() { return *pointer(); }
+  const Type &operator*() const { return *pointer(); }
+
+  Type *pointer() const { return resolve(); }
+
   [[nodiscard]] bool empty() const { return resolver_ == nullptr; }
   [[nodiscard]] bool valid() const { return !empty(); }
   [[nodiscard]] bool has_primary_key() const { return !pk_.is_null(); }
-  [[nodiscard]] const utils::identifier& primary_key() const { return pk_; }
+  [[nodiscard]] const utils::identifier &primary_key() const { return pk_; }
   void primary_key(const utils::identifier &pk) { pk_ = pk; }
 
 private:
   Type* resolve() const {
-    return resolver_->resolve(*this);
+    if (obj_) {
+      return obj_.get();
+    }
+
+    std::lock_guard lock(mutex_);
+    auto resolver = resolver_.lock();
+    if (!resolver) {
+      return nullptr;
+      // Todo: Add states (Detached, Attached, Transient) - if attached an no resolver is available throw runtime exception
+      // throw std::runtime_error("Detached proxy (session expired)");
+    }
+
+    const_cast<std::shared_ptr<Type>&>(obj_) = resolver->resolve(pk_);
+
+    return obj_.get();
   }
 
 private:
-    std::unique_ptr<object_resolver<Type>> resolver_{std::make_unique<static_object_resolver<Type>>()};
-    utils::identifier pk_{};
+  std::shared_ptr<Type> obj_{};
+  std::weak_ptr<object_resolver<Type>> resolver_{};
+  utils::identifier pk_{};
+  mutable std::mutex mutex_{};
 };
-
 }
 #endif //OBJECT_PROXY_HPP