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;
+    static_object_resolver() = default;
-    explicit simple_object_resolver(Type* obj)
+    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;
+  object_proxy() = default;
-    explicit object_proxy(Type* obj)
+  explicit object_proxy(Type* obj)
-    : resolver_(std::make_unique<simple_object_resolver<Type>>(obj)) {}
+  : resolver_(std::make_unique<static_object_resolver<Type>>(obj))
-    explicit object_proxy(std::unique_ptr<Type> obj)
+  , pk_(primary_key_resolver::resolve_object(*obj).pk) {}
-    : resolver_(std::move(obj)) {}
 
-    [[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->() const { return pointer(); }
-    Type& operator*() { return *pointer(); }
+  Type& operator*() { return *pointer(); }
-    const Type& operator*() const { return *pointer(); }
+  const Type& operator*() const { return *pointer(); }
 
-    Type* pointer() const { return resolve(); }
+  Type* pointer() const { return resolve(); }
 
-    Type& ref() { return *pointer(); }
+  Type& ref() { return *pointer(); }
-    const Type& ref() const { return *pointer(); }
+  const Type& ref() const { return *pointer(); }
 
-    void reset(Type* obj) {
+  void reset(Type* obj) {
-        resolver_ = std::make_unique<simple_object_resolver<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) {
+  }
-        resolver_ = std::make_unique<simple_object_resolver<Type>>(std::move(obj));
+  void reset(std::unique_ptr<Type> obj) {
-    }
+    pk_ = primary_key_resolver::resolve_object(*obj).pk;
-    void reset(std::unique_ptr<object_resolver<Type>> &&resolver) {
+    resolver_ = std::make_unique<static_object_resolver<Type>>(std::move(obj));
-        resolver_ = std::move(resolver);
+  }
-    }
+  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 {
+  Type* resolve() const {
-        return resolver_->resolve(*this);
+    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_{};
 };
 
 }

include/matador/object/object_ptr.hpp

@@ -4,7 +4,6 @@
 #include "matador/utils/identifier.hpp"
 
 #include "matador/object/object_proxy.hpp"
-#include "matador/object/primary_key_resolver.hpp"
 
 #include <memory>
 
@@ -15,8 +14,7 @@ public:
   object_ptr()
   : ptr_(std::make_shared<object_proxy<Type>>()) {}
   explicit object_ptr(Type *obj)
-  : ptr_(std::make_shared<object_proxy<Type>>(obj))
+  : ptr_(std::make_shared<object_proxy<Type>>(obj)) {}
-  , pk_(primary_key_resolver::resolve_object(*obj).pk) {}
   object_ptr(const object_ptr &other) : ptr_(other.ptr_) {}
   object_ptr(object_ptr &&other) noexcept : ptr_(std::move(other.ptr_)) {}
   object_ptr &operator=(const object_ptr &other) = default;
@@ -30,7 +28,6 @@ public:
   [[nodiscard]] bool empty() const { return ptr_->pointer() == nullptr; }
   void reset(Type *obj) {
     ptr_->reset(obj);
-    pk_ = primary_key_resolver::resolve_object(*obj).pk;
   }
 
   Type* get() const { return static_cast<Type*>(ptr_->pointer()); }
@@ -38,11 +35,11 @@ public:
   operator bool() { return valid(); }
   bool valid() { return ptr_ != nullptr; }
 
-  [[nodiscard]] const utils::identifier& primary_key() const { return pk_; }
+  [[nodiscard]] bool has_primary_key() const { return ptr_->has_primary_key(); }
-  void primary_key(const utils::identifier &pk) { pk_ = pk; }
+  [[nodiscard]] const utils::identifier& primary_key() const { return ptr_->primary_key(); }
+  void primary_key(const utils::identifier &pk) { ptr_->primary_key(pk); }
 private:
     std::shared_ptr<object_proxy<Type>> ptr_{};
-    utils::identifier pk_;
 };
 
 template<typename>

include/matador/object/primary_key_resolver.hpp

@@ -3,13 +3,16 @@
 
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
-#include "matador/utils/foreign_attributes.hpp"
 #include "matador/utils/identifier.hpp"
 #include "matador/utils/primary_key_attribute.hpp"
 
 #include <cstdint>
 #include <string>
 
+namespace matador::utils {
+class foreign_attributes;
+}
+
 namespace matador::object {
 
 struct primary_key_info {

include/matador/orm/session.hpp

@@ -29,6 +29,14 @@ struct session_context {
   size_t cache_size{500};
 };
 
+template<typename Type>
+class lazy_object_resolver final : public object::object_resolver<Type> {
+public:
+    Type* resolve(const object::object_proxy<Type>& proxy) const override {
+        return proxy.resolve();
+    }
+
+};
 class session final : public sql::executor {
 public:
   explicit session(session_context &&ctx);

source/core/utils/identifier.cpp

@@ -62,10 +62,10 @@ size_t identifier::null_pk::hash() const
 }
 
 identifier::identifier()
-  : id_(std::make_shared<null_pk>()) {}
+: id_(std::make_shared<null_pk>()) {}
 
 identifier::identifier(const identifier &x)
-  : id_(x.id_->copy()) {}
+: id_(x.id_->copy()) {}
 
 identifier &identifier::operator=(const identifier &x) {
   if (this == &x) {