[feature] linked list to textbox

Author: mrsrina

include/ekg/io/utf.hpp

@@ -30,6 +30,7 @@
 #include <string>
 #include <vector>
 #include <regex>
+#include <list>
 
 namespace ekg {
   /**
@@ -241,7 +242,7 @@ namespace ekg::io {
 namespace ekg {
   class text {
   protected:
-    std::vector<ekg::io::chunk_t> loaded_chunks {};
+    std::list<ekg::io::chunk_t> loaded_chunks {};
     size_t lines_per_chunk_limit {100000};
     size_t total_lines {};
     size_t total_chars {};
@@ -252,7 +253,7 @@ namespace ekg {
     bool should_count {};
   protected:
     void swizzle(
-      size_t chunk_index,
+      std::list<ekg::io::chunk_t>::iterator chunk_it,
       size_t line_index,
       std::vector<std::string> &to_swizzle,
       bool skip_first_line
@@ -282,7 +283,7 @@ namespace ekg {
       size_t end
     );
 
-    std::vector<ekg::io::chunk_t> &chunks_data();
+    std::list<ekg::io::chunk_t> &chunks_data();
     size_t length_of_chunks();
 
     std::string at(size_t index);
@@ -291,6 +292,7 @@ namespace ekg {
 
     bool audited();
     void unset_audited();
+    void gc();
   };
 }
 

include/ekg/ui/textbox/textbox.hpp

@@ -114,7 +114,7 @@ namespace ekg {
 
       size_t last_layers_select_size {};
       size_t view_line_index {UINT64_MAX};
-      size_t view_chunk_index {UINT64_MAX};
+      std::list<ekg::io::chunk_t>::iterator view_chunk_it {};
       size_t view_chunk_line_index {UINT64_MAX};
 
       ekg::vec2_t<size_t> picked_left {UINT64_MAX, UINT64_MAX};

src/io/utf.cpp

@@ -483,16 +483,15 @@ void ekg::utf8_concat(
 }
 
 void ekg::text::swizzle(
-  size_t chunk_index,
+  std::list<ekg::io::chunk_t>::iterator chunk_it,
   size_t line_index,
   std::vector<std::string> &to_swizzle,
   bool skip_first_line
 ) {
   this->was_audited = true;
-
   bool is_empty {to_swizzle.empty()};
-  ekg::io::chunk_t &chunk {this->loaded_chunks.at(chunk_index)};
 
+  ekg::io::chunk_t &chunk {*chunk_it};
   if (skip_first_line) {
     chunk.at(line_index) = is_empty ? "" : to_swizzle.at(0);
   }
@@ -528,18 +527,20 @@ void ekg::text::swizzle(
 
   for (size_t jt {}; jt < newly_chunks; jt++) {
     this->loaded_chunks.insert(
-      this->loaded_chunks.begin() + chunk_index + jt + 1,
+      chunk_it,
       ekg::io::chunk_t {
         to_swizzle_chunk.begin() + (this->lines_per_chunk_limit * (jt + 0)),
         to_swizzle_chunk.begin() + (this->lines_per_chunk_limit * (jt + 1))
       }
     );
+
+    chunk_it++;
   }
 
   size_t rest {to_swizzle_chunk_size - (this->lines_per_chunk_limit * newly_chunks)};
   if (rest > 0) {
     this->loaded_chunks.insert(
-      this->loaded_chunks.begin() + chunk_index + newly_chunks + 1,
+      chunk_it,
       ekg::io::chunk_t {
         to_swizzle_chunk.begin() + (this->lines_per_chunk_limit * (newly_chunks + 0)),
         to_swizzle_chunk.end()
@@ -561,8 +562,8 @@ size_t ekg::text::set(size_t index, std::string_view line, ekg::io::chunk_t &spl
   ekg::utf8_split_endings(line, split_endings);
 
   bool ok {};
-  for (size_t it {}; it < this->loaded_chunks.size(); it++) {
-    ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
+  for (std::list<ekg::io::chunk_t>::iterator it {this->loaded_chunks.begin()}; it != this->loaded_chunks.end(); it++) {
+    ekg::io::chunk_t &chunk {*it};
 
     previous_lines = current_lines;
     current_lines += (chunk_size = chunk.size());
@@ -591,8 +592,8 @@ std::string ekg::text::at(size_t index) {
   size_t previous_lines {};
   size_t chunk_size {};
 
-  for (size_t it {}; it < chunks_size; it++) {
-    ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
+  for (std::list<ekg::io::chunk_t>::iterator it {this->loaded_chunks.begin()}; it != this->loaded_chunks.end(); it++) {
+    ekg::io::chunk_t &chunk {*it};
     previous_lines = current_lines;
     current_lines += (chunk_size = chunk.size());
 
@@ -632,8 +633,8 @@ void ekg::text::insert(
   }
 
   size_t total_of_chunks {this->loaded_chunks.size()};
-  for (size_t it {}; it < total_of_chunks; it++) {
-    ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
+  for (std::list<ekg::io::chunk_t>::iterator it {this->loaded_chunks.begin()}; it != this->loaded_chunks.end(); it++) {
+    ekg::io::chunk_t &chunk {*it};
 
     previous_lines = current_lines;
     current_lines += (chunk_size = chunk.size());
@@ -681,8 +682,8 @@ std::string ekg::text::read(
   bool oka_end {};
 
   std::string builder {};
-  for (size_t it {}; it < total_of_chunks; it++) {
-    ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
+  for (std::list<ekg::io::chunk_t>::iterator it {this->loaded_chunks.begin()}; it != this->loaded_chunks.end(); it++) {
+    ekg::io::chunk_t &chunk {*it};
 
     previous_lines = current_lines;
     current_lines += (chunk_size = chunk.size());
@@ -767,8 +768,8 @@ void ekg::text::erase(
   bool empty_chunk {};
   bool goto_next_chunk {};
 
-  for (size_t it {}; it < this->loaded_chunks.size(); it++) {
-    ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
+  for (std::list<ekg::io::chunk_t>::iterator it {this->loaded_chunks.begin()}; it != this->loaded_chunks.end(); it++) {
+    ekg::io::chunk_t &chunk {*it};
 
     previous_lines = lines;
     lines += (chunk_size = chunk.size());
@@ -778,7 +779,7 @@ void ekg::text::erase(
       begin = begin - previous_lines;
 
       while (remains_lines != 0) {
-        ekg::io::chunk_t &chunk {this->loaded_chunks.at(it)};
+        ekg::io::chunk_t &chunk {*it};
 
         chunk_size = chunk.size();
         goto_next_chunk = begin + remains_lines > chunk.size();
@@ -791,12 +792,12 @@ void ekg::text::erase(
         empty_chunk = chunk.empty();
         if (empty_chunk) {
           this->loaded_chunks.erase(
-            this->loaded_chunks.begin() + it
+            it
           );
         }
 
         if (goto_next_chunk) {
-          it += !empty_chunk;
+          if (!empty_chunk) it++;
           remains_lines -= chunk_size - begin;
           begin = 0;
           continue;
@@ -819,23 +820,24 @@ void ekg::text::push_back(std::string_view line) {
 
   if (this->loaded_chunks.empty()) {
     this->loaded_chunks.emplace_back().emplace_back();
-    this->swizzle(0, 0, splitted, true);
+    this->swizzle(this->loaded_chunks.begin(), 0, splitted, true);
     return;
   }
 
+  std::list<ekg::io::chunk_t>::iterator last_it {--this->loaded_chunks.end()};
   ekg::io::chunk_t &last_chunk {
-    this->loaded_chunks.back()
+    *last_it
   };
 
   this->swizzle(
-    this->loaded_chunks.size() - 1,
+    last_it,
     last_chunk.size() - !last_chunk.empty(),
     splitted,
     false
   );
 }
 
-std::vector<ekg::io::chunk_t> &ekg::text::chunks_data() {
+std::list<ekg::io::chunk_t> &ekg::text::chunks_data() {
   return this->loaded_chunks;
 }
 

src/ui/textbox/widget.cpp

@@ -205,7 +205,7 @@ bool ekg::ui::find_index_by_interact(
 
   size_t chunk_size {};
   size_t il {};
-  size_t addition_chunk_index {};
+  size_t sum_chunk_sizes {};
   size_t text_total_lines {textbox.text.length_of_lines()};
 
   ekg::vec2_t<float> rendered {};
@@ -216,7 +216,7 @@ bool ekg::ui::find_index_by_interact(
   uint8_t uc8 {};
   char32_t c32 {};
 
-  std::vector<ekg::io::chunk_t> &chunks {textbox.text.chunks_data()};
+  std::list<ekg::io::chunk_t> &chunks {textbox.text.chunks_data()};
   size_t chunks_size {chunks.size()};
 
   index.y += textbox.widget.view_line_index;
@@ -234,13 +234,9 @@ bool ekg::ui::find_index_by_interact(
   std::string empty {"\n"};
   bool is_empty {};
 
-  for (size_t ic {textbox.widget.view_chunk_index}; ic < chunks_size; ic++) {
-    ekg::io::chunk_t &chunk {chunks.at(ic)};
-
-    il = 0;
-    if (ic == textbox.widget.view_chunk_index) {
-      il = textbox.widget.view_chunk_line_index;
-    }
+  il = textbox.widget.view_chunk_line_index;
+  for (std::list<ekg::io::chunk_t>::iterator ic {textbox.widget.view_chunk_it}; ic != chunks.end(); ic++) {
+    ekg::io::chunk_t &chunk {*ic};
 
     chunk_size = chunk.size();
     for (;il < chunk_size; il++) {
@@ -302,6 +298,7 @@ bool ekg::ui::find_index_by_interact(
         }
       }
 
+      il = 0;
       index.x = 0;
       pos.x = textbox.color_scheme.gutter_margin;
 
@@ -634,7 +631,7 @@ void ekg::ui::reload(
   textbox.rect.h = aligned_dimension.h * textbox.rect.scaled_height;
 
   size_t highest_size {};
-  std::vector<ekg::io::chunk_t> &chunks {textbox.text.chunks_data()};
+  std::list<ekg::io::chunk_t> &chunks {textbox.text.chunks_data()};
 
   ekg::rect_t<float> &rect_abs {
     ekg::ui::get_abs_rect(property, textbox.rect)
@@ -1353,13 +1350,13 @@ void ekg::ui::buffering(
   size_t text_total_chars {textbox.text.length_of_chars()};
   size_t text_total_lines {textbox.text.length_of_lines()};
   size_t il {};
-  size_t addition_chunk_index {};
+  size_t sum_chunk_sizes {};
   size_t chunk_size {};
   ekg::vec2_t<size_t> index {};
 
   ekg::pixel_t line_wsize {};
   ekg::textbox_t::cursor_t cursor {};
-  std::vector<ekg::io::chunk_t> &chunks {textbox.text.chunks_data()};
+  std::list<ekg::io::chunk_t> &chunks {textbox.text.chunks_data()};
   size_t chunks_size {chunks.size()};
   bool is_renderable {};
 
@@ -1403,26 +1400,26 @@ void ekg::ui::buffering(
   bool was_empty_before {};
 
   textbox.widget.layers_select.clear();
-  for (size_t ic {}; ic < chunks_size; ic++) {
-    ekg::io::chunk_t &chunk {chunks.at(ic)};
+  for (std::list<ekg::io::chunk_t>::iterator ic {chunks.begin()}; ic != chunks.end(); ic++) {
+    ekg::io::chunk_t &chunk {*ic};
     chunk_size = chunk.size();
-    if (addition_chunk_index + chunk_size < textbox.widget.view_line_index) {
+    if (sum_chunk_sizes + chunk_size < textbox.widget.view_line_index) {
       pos.x = 0.0f;
       index.y += chunk_size;
-      addition_chunk_index += chunk_size;
+      sum_chunk_sizes += chunk_size;
       continue;
     }
 
     il = 0;
     if (!oka_found_visual_index) {
-      textbox.widget.view_chunk_index = ic;
-      il = textbox.widget.view_line_index - addition_chunk_index;
+      textbox.widget.view_chunk_it = ic;
+      il = textbox.widget.view_line_index - sum_chunk_sizes;
       textbox.widget.view_chunk_line_index = il;
       index.y += il;
       oka_found_visual_index = true;
     }
 
-    addition_chunk_index += chunk_size;
+    sum_chunk_sizes += chunk_size;
     for (;il < chunk_size; il++) {
       std::string &chunk_line {chunk.at(il)};
       std::string &line {(is_empty = chunk_line.empty()) ? empty : chunk_line};