removed object_definition class

include/matador/object/attribute_definition.hpp

@@ -30,28 +30,11 @@ public:
   attribute_definition& operator=(attribute_definition&&) noexcept = default;
 
   attribute_definition() = default;
-
-  // template<typename Type>
-  //  attribute_definition(std::string name, const utils::field_attributes& attr)
-  // : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), attr)
-  // {}
-  //
-  // template<size_t SIZE>
-  // attribute_definition(std::string name, const char (&)[SIZE], const utils::field_attributes& attr, const null_option_type null_opt)
-  // : attribute_definition(std::move(name), utils::data_type_traits<const char*>::type(attr.size()), attr, null_opt)
-  // {}
-
   attribute_definition(std::string name,
                        utils::basic_type type,
                        const utils::field_attributes&,
                        null_option_type null_opt,
                        int index = 0);
-
-  // template<typename Type>
-  // attribute_definition(std::string name, const std::shared_ptr<attribute_definition> &ref_column, const utils::field_attributes& attr, null_option_type null_opt)
-  // : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), ref_column, attr, null_opt)
-  // {}
-  //
   attribute_definition(std::string name,
                        utils::basic_type type,
                        int index,
@@ -102,10 +85,7 @@ public:
   }
 
 private:
-  friend class object_definition;
-
   std::string name_;
-  // std::shared_ptr<object_definition> object_{};
   std::string table_name_;
   attribute_options options_;
   utils::basic_type type_{utils::basic_type::type_null};

include/matador/object/basic_object_info.hpp

@@ -1,7 +1,7 @@
 #ifndef BASIC_PROTOTYPE_INFO_HPP
 #define BASIC_PROTOTYPE_INFO_HPP
 
-#include "matador/object/object_definition.hpp"
+#include "matador/object/attribute_definition.hpp"
 #include "matador/object/relation_endpoint.hpp"
 
 #include "matador/utils/identifier.hpp"
@@ -49,14 +49,12 @@ 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, const std::shared_ptr<object_definition> &definition);
   basic_object_info(std::shared_ptr<repository_node> node, const std::vector<attribute_definition> &attributes, utils::identifier &&pk, const std::shared_ptr<attribute_definition> &pk_as_fk_column);
   basic_object_info(std::shared_ptr<repository_node> node, const std::vector<attribute_definition> &attributes);
 
 protected:
   std::shared_ptr<repository_node> node_;            /**< prototype node of the represented object type */
   std::vector<attribute_definition> attributes_;
-  // std::shared_ptr<object_definition> definition_;
   std::optional<utils::identifier> identifier_;
   std::shared_ptr<attribute_definition> pk_as_fk_column_;
   t_endpoint_map relation_endpoints_;

include/matador/object/object_definition.hpp

@@ -1,77 +0,0 @@
-#ifndef QUERY_TABLE_DEFINITION_HPP
-#define QUERY_TABLE_DEFINITION_HPP
-
-#include "matador/object/attribute_definition.hpp"
-
-#include <optional>
-#include <unordered_map>
-
-namespace matador::object {
-
-class object_definition final {
-private:
-  using column_by_index = std::vector<attribute_definition>;
-  using column_index_pair = std::pair<std::reference_wrapper<attribute_definition>, column_by_index::difference_type>;
-  using column_by_name_map = std::unordered_map<std::string, column_index_pair>;
-
-public:
-  using iterator = column_by_index::iterator;
-  using const_iterator = column_by_index::const_iterator;
-
-  object_definition() = default;
-  explicit object_definition(std::string name);
-  object_definition(std::string name, std::initializer_list<attribute_definition> columns);
-  explicit object_definition(std::string name, const std::vector<attribute_definition> &columns);
-  object_definition(const object_definition &x);
-  object_definition& operator=(const object_definition &x);
-  object_definition(object_definition&&) noexcept = default;
-  object_definition& operator=(object_definition&&) noexcept = default;
-  ~object_definition() = default;
-
-  [[nodiscard]] const std::string& name() const;
-
-  [[nodiscard]] bool has_primary_key() const;
-  [[nodiscard]] std::optional<attribute_definition> primary_key() const;
-
-  template < typename Type >
-  void append(const std::string &name, long size = -1) {
-    append(make_column<Type>(name, size));
-  }
-  void append(attribute_definition&& col);
-
-  [[nodiscard]] const std::vector<attribute_definition>& columns() const;
-
-  [[nodiscard]] const attribute_definition& at(const std::string &name) const;
-  [[nodiscard]] const attribute_definition& at(size_t index) const;
-
-  iterator find(const std::string &column_name);
-  [[nodiscard]] const_iterator find(const std::string &column_name) const;
-
-  iterator begin();
-  [[nodiscard]] const_iterator begin() const;
-  [[nodiscard]] const_iterator cbegin() const;
-
-  iterator end();
-  [[nodiscard]] const_iterator end() const;
-  [[nodiscard]] const_iterator cend() const;
-
-  [[nodiscard]] size_t size() const;
-  [[nodiscard]] bool empty() const;
-  void clear();
-
-private:
-  void init();
-  void add_to_map(attribute_definition &col, size_t index);
-
-private:
-  friend class repository_node;
-
-  std::string name_;
-  column_by_index columns_;
-  column_by_name_map columns_by_name_;
-
-  int pk_index_{-1};
-};
-
-}
-#endif //QUERY_TABLE_DEFINITION_HPP

include/matador/object/object_info.hpp

@@ -2,7 +2,6 @@
 #define OBJECT_INFO_HPP
 
 #include "matador/object/basic_object_info.hpp"
-// #include "matador/object/object_definition.hpp"
 
 namespace matador::object {
 class repository_node;
@@ -12,30 +11,16 @@ class object_info final : public basic_object_info {
 public:
   using create_func = std::function<std::unique_ptr<Type>()>;
 
-  // object_info(const std::shared_ptr<repository_node>& node,
-  //             const std::shared_ptr<attribute_definition> &ref_column)
-  // : basic_object_info(node, {}, ref_column, {})
-  // , creator_([]{return std::make_unique<Type>(); }){
-  // }
-  // object_info(const std::shared_ptr<repository_node>& node,
-  //             utils::identifier &&pk,
-  //             const std::shared_ptr<attribute_definition> &ref_column,
-  //             object_definition &&definition)
-  // : basic_object_info(node, std::move(pk), ref_column, std::move(definition))
-  // , creator_([]{return std::make_unique<Type>(); }){
-  // }
   object_info(const std::shared_ptr<repository_node>& node,
               const std::vector<attribute_definition> &attributes,
               utils::identifier &&pk,
               const std::shared_ptr<attribute_definition> &ref_column,
-              // object_definition &&definition,
               create_func&& creator)
-  : basic_object_info(node, attributes, std::move(pk), ref_column/*, std::move(definition)*/)
+  : basic_object_info(node, attributes, std::move(pk), ref_column)
   , creator_(std::move(creator)){
   }
   object_info(const std::shared_ptr<repository_node>& node,
               const std::vector<attribute_definition> &attributes,
-              // object_definition &&definition,
               create_func&& creator)
   : basic_object_info(node, attributes)
   , creator_(std::move(creator)){

include/matador/object/repository_node.hpp

@@ -21,13 +21,9 @@ public:
     auto node = std::shared_ptr<repository_node>(new repository_node(repo, name, typeid(Type)));
 
     primary_key_resolver resolver;
-    // 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));
-    // }
     auto info = std::make_unique<object_info<Type>>(
       node,
       attributes,

include/matador/orm/session.hpp

@@ -15,7 +15,6 @@
 #include "matador/sql/statement_cache.hpp"
 
 #include "matador/object/object_ptr.hpp"
-#include "matador/object/object_definition.hpp"
 #include "matador/object/repository.hpp"
 
 #include <unordered_map>

source/core/CMakeLists.txt

@@ -20,7 +20,6 @@ add_library(matador-core STATIC
   ../../include/matador/object/foreign_node_completer.hpp
   ../../include/matador/object/internal/shadow_repository.hpp
   ../../include/matador/object/many_to_many_relation.hpp
-  ../../include/matador/object/object_definition.hpp
   ../../include/matador/object/object_info.hpp
   ../../include/matador/object/object_proxy.hpp
   ../../include/matador/object/object_ptr.hpp
@@ -81,7 +80,6 @@ add_library(matador-core STATIC
   object/error_code.cpp
   object/foreign_node_completer.cpp
   object/internal/shadow_repository.cpp
-  object/object_definition.cpp
   object/relation_endpoint.cpp
   object/repository.cpp
   object/repository_node.cpp

source/core/object/attribute_definition.cpp

@@ -1,7 +1,5 @@
 #include "matador/object/attribute_definition.hpp"
 
-#include "matador/object/object_definition.hpp"
-
 #include <ostream>
 #include <utility>
 
@@ -59,14 +57,6 @@ std::string attribute_definition::full_name() const {
   return !table_name_.empty() ? table_name_ + "." + name_ : name_;
 }
 
-// std::shared_ptr<object_definition> attribute_definition::object() const {
-//   return object_;
-// }
-//
-// void attribute_definition::object(const std::shared_ptr<object_definition>& obj) {
-//   object_ = obj;
-// }
-//
 int attribute_definition::index() const {
   return options_.index;
 }

source/core/object/basic_object_info.cpp

@@ -5,16 +5,6 @@
 #include <algorithm>
 
 namespace matador::object {
-// basic_object_info::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)
-// : node_(std::move(node))
-// , definition_(definition)
-// , identifier_(std::move(pk))
-// , pk_column_(pk_column) {
-// }
-
 basic_object_info::basic_object_info(std::shared_ptr<repository_node> node,
                                      const std::vector<attribute_definition> &attributes,
                                      utils::identifier &&pk,

source/core/object/object_definition.cpp

@@ -1,153 +0,0 @@
-#include "matador/object/object_definition.hpp"
-
-namespace matador::object {
-object_definition::object_definition(std::string name)
-: name_(std::move(name)) {}
-
-object_definition::object_definition(std::string name, const std::initializer_list<attribute_definition> columns)
-: name_(std::move(name))
-, columns_(columns) {
-  init();
-}
-
-object_definition::object_definition(std::string name, const std::vector<attribute_definition> &columns)
-: name_(std::move(name))
-, columns_(columns) {
-  init();
-}
-
-object_definition::object_definition(const object_definition &x)
-: name_(x.name_)
-, columns_(x.columns_)
-, pk_index_(x.pk_index_) {
-  for (auto& col : columns_) {
-    add_to_map(col, col.index());
-  }
-}
-
-object_definition &object_definition::operator=(const object_definition &x)
-{
-  if (&x == this) {
-    return *this;
-  }
-
-  name_ = x.name_;
-  columns_ = x.columns_;
-  columns_by_name_.clear();
-  pk_index_ = x.pk_index_;
-  for (auto& col : columns_) {
-    add_to_map(col, col.index());
-  }
-  return *this;
-}
-
-const std::string& object_definition::name() const {
-  return name_;
-}
-
-bool object_definition::has_primary_key() const {
-    return pk_index_ > -1;
-}
-
-std::optional<attribute_definition> object_definition::primary_key() const
-{
-  if (!has_primary_key()) {
-    return std::nullopt;
-  }
-
-  return columns_[pk_index_];
-}
-
-void object_definition::append(attribute_definition&& col) {
-  auto &ref = columns_.emplace_back(std::move(col));
-  add_to_map(ref, columns_.size()-1);
-}
-
-const std::vector<object::attribute_definition> &object_definition::columns() const {
-  return columns_;
-}
-
-const attribute_definition &object_definition::at(const std::string &name) const
-{
-  return columns_by_name_.at(name).first;
-}
-
-const attribute_definition &object_definition::at( const size_t index) const
-{
-  return columns_.at(index);
-}
-
-object_definition::iterator object_definition::find(const std::string &column_name)
-{
-  const auto it = columns_by_name_.find(column_name);
-  return it != columns_by_name_.end() ? columns_.begin() + it->second.second : columns_.end();
-}
-
-object_definition::const_iterator object_definition::find(const std::string &column_name) const {
-  const auto it = columns_by_name_.find(column_name);
-  return it != columns_by_name_.end() ? columns_.begin() + it->second.second : columns_.end();
-}
-
-object_definition::iterator object_definition::begin()
-{
-  return columns_.begin();
-}
-
-object_definition::const_iterator object_definition::begin() const
-{
-  return columns_.begin();
-}
-
-object_definition::const_iterator object_definition::cbegin() const
-{
-  return columns_.cbegin();
-}
-
-object_definition::iterator object_definition::end()
-{
-  return columns_.end();
-}
-
-object_definition::const_iterator object_definition::end() const
-{
-  return columns_.end();
-}
-
-object_definition::const_iterator object_definition::cend() const
-{
-  return columns_.cend();
-}
-
-size_t object_definition::size() const
-{
-  return columns_.size();
-}
-
-bool object_definition::empty() const
-{
-  return columns_.empty();
-}
-
-void object_definition::clear()
-{
-  columns_.clear();
-  columns_by_name_.clear();
-}
-
-void object_definition::init()
-{
-  size_t index{0};
-  for(auto &col : columns_) {
-    add_to_map(col, index++);
-  }
-}
-
-void object_definition::add_to_map(attribute_definition &col, size_t index)
-{
-  columns_by_name_.emplace(col.name(), column_index_pair {std::ref(col), index});
-  if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {
-    pk_index_ = static_cast<int>(index);
-  }
-}
-
-}

source/orm/query/query_compiler.cpp

@@ -1,7 +1,5 @@
 #include "matador/query/query_compiler.hpp"
 
-#include "matador/object/object_definition.hpp"
-
 #include "matador/query/attribute_string_writer.hpp"
 #include "matador/query/query_data.hpp"
 #include "matador/query/criteria_evaluator.hpp"

test/orm/sql/ColumnTest.cpp

@@ -1,7 +1,6 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "matador/object/attribute_definition.hpp"
-#include "matador/object/object_definition.hpp"
 
 using namespace matador::object;
 using namespace matador::utils;