compilation fixes

include/matador/object/attribute_definition.hpp

@@ -4,10 +4,8 @@
 #include "matador/utils/basic_types.hpp"
 #include "matador/utils/default_type_traits.hpp"
 #include "matador/utils/field_attributes.hpp"
-#include "matador/utils/value.hpp"
 
 #include <memory>
-#include <vector>
 
 namespace matador::object {
 
@@ -95,14 +93,9 @@ public:
     return type() == utils::data_type_traits<Type>::type(attributes().size());
   }
 
-private:
-  using data_type_index = std::vector<utils::basic_type>;
-
 private:
   friend class object_definition;
 
-  static const data_type_index data_type_index_;
-
   std::string name_;
   std::shared_ptr<object_definition> object_{};
   attribute_options options_;

include/matador/object/attribute_definition_generator.hpp

@@ -8,7 +8,7 @@
 #include "matador/utils/error.hpp"
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/primary_key_attribute.hpp"
-
+#include "matador/utils/result.hpp"
 
 #include <memory>
 #include <typeindex>

include/matador/object/basic_object_info.hpp

@@ -24,7 +24,7 @@ public:
 
   [[nodiscard]] std::type_index type_index() const;
   [[nodiscard]] std::string name() const;
-  [[nodiscard]] const object_definition& definition() const;
+  [[nodiscard]] std::shared_ptr<object_definition> definition() const;
   [[nodiscard]] std::shared_ptr<attribute_definition> reference_column() const;
 
   [[nodiscard]] bool has_primary_key() const;
@@ -49,13 +49,13 @@ public:
   [[nodiscard]] bool endpoints_empty() const;
 
 protected:
-  basic_object_info(std::shared_ptr<repository_node> node, utils::identifier &&pk, const std::shared_ptr<attribute_definition> &pk_column, object_definition &&definition);
+  basic_object_info(std::shared_ptr<repository_node> node, utils::identifier &&pk, const std::shared_ptr<attribute_definition> &pk_column, const std::shared_ptr<object_definition> &definition);
   basic_object_info(std::shared_ptr<repository_node> node, utils::identifier &&pk, const std::shared_ptr<attribute_definition> &pk_column);
-  basic_object_info(std::shared_ptr<repository_node> node, object_definition &&definition);
+  basic_object_info(std::shared_ptr<repository_node> node, const std::shared_ptr<object_definition> &definition);
 
 protected:
   std::shared_ptr<repository_node> node_;            /**< prototype node of the represented object type */
-  object_definition definition_;
+  std::shared_ptr<object_definition> definition_;
   std::optional<utils::identifier> identifier_;
   std::shared_ptr<attribute_definition> pk_column_;
   t_endpoint_map relation_endpoints_;

include/matador/object/object_definition.hpp

@@ -3,6 +3,7 @@
 
 #include "matador/object/attribute_definition.hpp"
 
+#include <optional>
 #include <unordered_map>
 
 namespace matador::object {

include/matador/object/repository.hpp

@@ -161,7 +161,6 @@ private:
   using t_type_index_node_map = std::unordered_map<std::type_index, node_ptr>;
 
   [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const node_ptr &node, const std::string &parent);
-  // [[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const node_ptr &node, const std::type_index &type_index);
   [[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::string &name) const;
   [[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::type_index &type_index) const;
   template<typename Type>

include/matador/object/repository_node.hpp

@@ -21,18 +21,18 @@ public:
     auto node = std::shared_ptr<repository_node>(new repository_node(repo, name, typeid(Type)));
 
     primary_key_resolver resolver;
-    object_definition obj{name, {}};
+    auto obj = std::make_shared<object_definition>(name);
     auto pk_info = resolver.resolve<Type>();
     auto ref_column = determine_reference_column(typeid(Type), name, pk_info, repo);
     const auto attributes = attribute_definition_generator::generate<Type>(repo);
     for (auto&& attr : attributes) {
-      obj.append(std::move(attr));
+      obj->append(std::move(attr));
     }
     auto info = std::make_unique<object_info<Type>>(
       node,
       std::move(pk_info.pk),
       ref_column,
-      std::move(obj),
+      obj,
       []{ return std::make_unique<Type>(); }
     );
     node->info_ = std::move(info);
@@ -41,8 +41,8 @@ public:
   }
 
   template < typename Type, typename CreatorFunc >
-  static utils::result<node_ptr, utils::error> make_relation_node(object::repository& tree, const std::string& name, CreatorFunc &&creator) {
-    const auto result = make_and_attach_node(tree, name, typeid(Type));
+  static utils::result<node_ptr, utils::error> make_relation_node(repository& repo, const std::string& name, CreatorFunc &&creator) {
+    const auto result = make_and_attach_node(repo, name, typeid(Type));
     if (!result) {
         return result;
     }
@@ -50,7 +50,7 @@ public:
     auto obj = creator();
     auto info = std::make_unique<object_info<Type>>(
         result.value(),
-        object_definition{attribute_definition_generator::generate(*obj, tree)},
+        std::make_shared<object_definition>(attribute_definition_generator::generate(*obj, repo)),
         std::move(creator)
     );
     result.value()->info_ = std::move(info);
@@ -58,7 +58,7 @@ public:
     return result;
   }
 
-  static std::shared_ptr<repository_node> make_null_node(repository& tree);
+  static std::shared_ptr<repository_node> make_null_node(repository& repo);
 
   repository_node(const repository_node& other) = delete;
   repository_node(repository_node&& other) = default;
@@ -81,20 +81,20 @@ public:
       return std::ref(static_cast<const object_info<Type>&>(*info_));
   }
 
-  [[nodiscard]] const object::repository& schema() const;
+  [[nodiscard]] const repository& schema() const;
 
   [[nodiscard]] bool has_children() const;
 
 private:
-  explicit repository_node(object::repository& tree);
-  repository_node(object::repository& tree, const std::type_index& ti);
-  repository_node(object::repository& tree, std::string name, const std::type_index& ti);
+  explicit repository_node(repository& repo);
+  repository_node(repository& repo, const std::type_index& ti);
+  repository_node(repository& repo, std::string name, const std::type_index& ti);
 
   void unlink();
 
   static utils::result<node_ptr, utils::error> make_and_attach_node(repository& repo, const std::string& name, const std::type_index& ti);
   static std::shared_ptr<attribute_definition> determine_reference_column(const std::type_index& ti,
-                                                                          object_definition& obj,
+                                                                          const std::shared_ptr<object_definition>& obj,
                                                                           const primary_key_info& pk_info,
                                                                           repository& repo);