Add Field_Framework class

Author: judith-ipac

src/Data_Element.hxx

@@ -1,36 +1,68 @@
 #pragma once
 
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/xml_parser.hpp>
-
 #include "Column.hxx"
-
-// JTODO: Create struct to hold commonly used (columns, offsets) pair?
+#include "Field_Framework.hxx"
 
 namespace tablator {
 
 class Data_Element {
 public:
-    Data_Element(const std::vector<Column> &columns, const std::vector<size_t> &offsets,
+    Data_Element(const Field_Framework &field_framework,
                  const std::vector<uint8_t> &data)
-            : columns_(columns), offsets_(offsets), data_(data) {}
+            : field_framework_(field_framework), data_(data) {}
+
+    Data_Element(const Field_Framework &field_framework)
+            : Data_Element(field_framework, std::vector<uint8_t>()) {}
+
 
     // accessors
-    inline const std::vector<Column> &get_columns() const { return columns_; }
-    inline std::vector<Column> &get_columns() { return columns_; }
+    const Field_Framework &get_field_framework() const { return field_framework_; }
+
+    Field_Framework &get_field_framework() { return field_framework_; }
+
+
+    inline const std::vector<Column> &get_columns() const {
+        return field_framework_.get_columns();
+    }
 
-    inline const std::vector<size_t> &get_offsets() const { return offsets_; }
-    inline std::vector<size_t> &get_offsets() { return offsets_; }
+    // Non-const to allow query_server to modify field_properties.
+    inline std::vector<Column> &get_columns() { return field_framework_.get_columns(); }
+
+    inline const std::vector<size_t> &get_offsets() const {
+        return field_framework_.get_offsets();
+    }
+
+    size_t get_row_size() const { return field_framework_.get_row_size(); }
+
+    size_t get_num_rows() const {
+        if (get_row_size() == 0) {
+            return 0;
+        }
+        return data_.size() / get_row_size();
+    }
+
+    // called by query_server to trim result set
+    void resize_data(size_t &new_num_rows) {
+        data_.resize(get_row_size() * new_num_rows);
+    }
+
+    void reserve_data(size_t &new_num_rows) {
+        data_.reserve(get_row_size() * new_num_rows);
+    }
 
 
     inline const std::vector<uint8_t> &get_data() const { return data_; }
+
+    // Non-const to support append_rows().
     inline std::vector<uint8_t> &get_data() { return data_; }
 
     inline void set_data(const std::vector<uint8_t> &d) { data_ = d; }
 
 private:
-    std::vector<Column> columns_;
-    std::vector<size_t> offsets_ = {0};
+    // Non-const to allow query_server to update column's field_properties.
+    Field_Framework field_framework_;
+
+    // Non-const because of append_rows().
     std::vector<uint8_t> data_;
 };
 

src/Field_Framework.hxx

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "Column.hxx"
+#include "Utils/Null_Utils.hxx"
+
+namespace tablator {
+
+class Field_Framework {
+public:
+    Field_Framework(const std::vector<Column> &incoming_columns,
+                    bool got_null_bitfields_column = false)
+            : offsets_({0}) {
+        if ((got_null_bitfields_column && incoming_columns.size() == 1) ||
+            incoming_columns.empty()) {
+            throw std::runtime_error(
+                    "Field_Framework constructor: <visible_columns> must be "
+                    "non-empty.");
+        }
+        // JTODO avoid copies
+        if (!got_null_bitfields_column) {
+            const size_t null_flags_size = bits_to_bytes(incoming_columns.size() + 1);
+            append_column(null_bitfield_flags_name, Data_Type::UINT8_LE,
+                          null_flags_size,
+                          Field_Properties::Builder()
+                                  .add_description(null_bitfield_flags_description)
+                                  .build());
+        }
+
+        for (auto &col : incoming_columns) {
+            append_column(col);
+        }
+    }
+
+    // accessors
+
+    inline size_t get_row_size() const {
+        if (offsets_.empty()) {
+            throw std::runtime_error("<offsets> is empty");
+        }
+        return offsets_.back();
+    }
+
+    inline const std::vector<Column> &get_columns() const { return columns_; }
+    inline std::vector<Column> &get_columns() { return columns_; }
+
+    inline const std::vector<size_t> &get_offsets() const { return offsets_; }
+    inline std::vector<size_t> &get_offsets() { return offsets_; }
+
+
+private:
+    void append_column(const Column &column) {
+        columns_.emplace_back(column);
+        size_t old_row_size = *offsets_.rbegin();
+        size_t new_row_size = old_row_size + columns_.rbegin()->get_data_size();
+        offsets_.push_back(new_row_size);
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &array_size,
+                              const Field_Properties &field_properties,
+                              bool dynamic_array_flag) {
+        append_column(
+                Column(name, type, array_size, field_properties, dynamic_array_flag));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &array_size,
+                              const Field_Properties &field_properties) {
+        append_column(Column(name, type, array_size, field_properties));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &array_size, bool dynamic_array_flag) {
+        append_column(Column(name, type, array_size, dynamic_array_flag));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &size) {
+        append_column(Column(name, type, size));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const Field_Properties &field_properties) {
+        append_column(Column(name, type, field_properties));
+    }
+
+
+    inline void append_column(const std::string &name, const Data_Type &type) {
+        append_column(Column(name, type));
+    }
+
+    std::vector<Column> columns_;
+    std::vector<size_t> offsets_;
+};
+
+}  // namespace tablator

src/Resource_Element.hxx

@@ -373,23 +373,43 @@ public:
         return get_table_elements().at(MAIN_TABLE_ELEMENT_IDX);
     }
 
+    const Field_Framework &get_field_framework() const {
+        return get_main_table_element().get_field_framework();
+    }
+
+    Field_Framework &get_field_framework() {
+        return get_main_table_element().get_field_framework();
+    }
+
     const std::vector<Column> &get_columns() const {
         return get_main_table_element().get_columns();
     }
+
     std::vector<Column> &get_columns() {
         return get_main_table_element().get_columns();
     }
 
     const std::vector<size_t> &get_offsets() const {
         return get_main_table_element().get_offsets();
     }
-    std::vector<size_t> &get_offsets() {
-        return get_main_table_element().get_offsets();
+
+    size_t get_row_size() const { return get_main_table_element().get_row_size(); }
+    size_t get_num_rows() const { return get_main_table_element().get_num_rows(); }
+
+    // called by query_server to trim result set
+    void resize_data(size_t &new_num_rows) {
+        get_main_table_element().resize_data(new_num_rows);
+    }
+
+    // called by query_server to trim result set
+    void reserve_data(size_t &new_num_rows) {
+        get_main_table_element().reserve_data(new_num_rows);
     }
 
     std::vector<Field> &get_table_element_params() {
         return get_main_table_element().get_params();
     }
+
     const std::vector<Field> &get_table_element_params() const {
         return get_main_table_element().get_params();
     }