proxy lazy resolve progress

include/matador/object/object_proxy.hpp

@@ -1,6 +1,8 @@
 #ifndef OBJECT_PROXY_HPP
 #define OBJECT_PROXY_HPP
 
+#include "matador/object/primary_key_resolver.hpp"
+
 #include <memory>
 
 namespace matador::object {
@@ -24,12 +26,12 @@ public:
 };
 
 template < typename Type >
-class simple_object_resolver final : public object_resolver<Type> {
+class static_object_resolver final : public object_resolver<Type> {
 public:
-    simple_object_resolver() = default;
-    explicit simple_object_resolver(Type* obj)
+    static_object_resolver() = default;
+    explicit static_object_resolver(Type* obj)
     : obj_(obj) {}
-    explicit simple_object_resolver(std::unique_ptr<Type> obj)
+    explicit static_object_resolver(std::unique_ptr<Type> obj)
     : obj_(std::move(obj)) {}
 
     Type* resolve(const object_proxy<Type> &/*proxy*/) const override {
@@ -44,40 +46,48 @@ private:
 template<class Type>
 class object_proxy final : public basic_object_proxy {
 public:
-    object_proxy() = default;
-    explicit object_proxy(Type* obj)
-    : resolver_(std::make_unique<simple_object_resolver<Type>>(obj)) {}
-    explicit object_proxy(std::unique_ptr<Type> obj)
-    : resolver_(std::move(obj)) {}
+  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()); }
+  [[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* operator->() const { return pointer(); }
+  Type& operator*() { return *pointer(); }
+  const Type& operator*() const { return *pointer(); }
 
-    Type* pointer() const { return resolve(); }
+  Type* pointer() const { return resolve(); }
 
-    Type& ref() { return *pointer(); }
-    const Type& ref() const { return *pointer(); }
+  Type& ref() { return *pointer(); }
+  const Type& ref() const { return *pointer(); }
 
-    void reset(Type* obj) {
-        resolver_ = std::make_unique<simple_object_resolver<Type>>(obj);
-    }
-    void reset(std::unique_ptr<Type> obj) {
-        resolver_ = std::make_unique<simple_object_resolver<Type>>(std::move(obj));
-    }
-    void reset(std::unique_ptr<object_resolver<Type>> &&resolver) {
-        resolver_ = std::move(resolver);
-    }
+  void reset(Type* obj) {
+    pk_ = primary_key_resolver::resolve_object(*obj).pk;
+    resolver_ = std::make_unique<static_object_resolver<Type>>(obj);
+  }
+  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));
+  }
+  void reset(std::unique_ptr<object_resolver<Type>> &&resolver) {
+    resolver_ = std::move(resolver);
+  }
+
+  [[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_; }
+  void primary_key(const utils::identifier &pk) { pk_ = pk; }
 
 private:
-    Type* resolve() const {
-        return resolver_->resolve(*this);
-    }
+  Type* resolve() const {
+    return resolver_->resolve(*this);
+  }
 
 private:
-    std::unique_ptr<object_resolver<Type>> resolver_{std::make_unique<simple_object_resolver<Type>>()};
+    std::unique_ptr<object_resolver<Type>> resolver_{std::make_unique<static_object_resolver<Type>>()};
+    utils::identifier pk_{};
 };
 
 }