kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

changes.hh (3877B)


      1 #ifndef changes_hh_INCLUDED
      2 #define changes_hh_INCLUDED
      3 
      4 #include "buffer.hh"
      5 #include "coord.hh"
      6 
      7 #include <algorithm>
      8 
      9 namespace Kakoune
     10 {
     11 
     12 // This tracks position changes for changes that are done
     13 // in a forward way (each change takes place at a position)
     14 // *after* the previous one.
     15 struct ForwardChangesTracker
     16 {
     17     BufferCoord cur_pos; // last change position at current modification
     18     BufferCoord old_pos; // last change position at start
     19 
     20     void update(const Buffer::Change& change);
     21     void update(const Buffer& buffer, size_t& timestamp);
     22 
     23     BufferCoord get_old_coord(BufferCoord coord) const;
     24     BufferCoord get_new_coord(BufferCoord coord) const;
     25     BufferCoord get_new_coord_tolerant(BufferCoord coord) const;
     26 
     27     bool relevant(const Buffer::Change& change, BufferCoord old_coord) const;
     28 };
     29 
     30 const Buffer::Change* forward_sorted_until(const Buffer::Change* first, const Buffer::Change* last);
     31 const Buffer::Change* backward_sorted_until(const Buffer::Change* first, const Buffer::Change* last);
     32 
     33 template<typename Range, typename AdvanceFunc>
     34 auto update_range(ForwardChangesTracker& changes_tracker, Range& range, AdvanceFunc&& advance_while_relevant)
     35 {
     36     auto& first = get_first(range);
     37     auto& last = get_last(range);
     38     advance_while_relevant(first);
     39     first = changes_tracker.get_new_coord_tolerant(first);
     40 
     41     if (last < BufferCoord{0,0})
     42         return;
     43 
     44     advance_while_relevant(last);
     45     last = changes_tracker.get_new_coord_tolerant(last);
     46 }
     47 
     48 template<typename RangeContainer>
     49 void update_forward(ConstArrayView<Buffer::Change> changes, RangeContainer& ranges)
     50 {
     51     ForwardChangesTracker changes_tracker;
     52     auto advance_while_relevant = [&, it = changes.begin()]
     53                                   (const BufferCoord& pos) mutable {
     54         while (it != changes.end() and changes_tracker.relevant(*it, pos))
     55             changes_tracker.update(*it++);
     56     };
     57 
     58     auto range_it = std::lower_bound(ranges.begin(), ranges.end(), changes.front(),
     59                                      [](auto& range, const Buffer::Change& change) { return get_last(range) < change.begin; });
     60     for (auto end = ranges.end(); range_it != end; ++range_it)
     61         update_range(changes_tracker, *range_it, advance_while_relevant);
     62 }
     63 
     64 template<typename RangeContainer>
     65 void update_backward(ConstArrayView<Buffer::Change> changes, RangeContainer& ranges)
     66 {
     67     ForwardChangesTracker changes_tracker;
     68     auto advance_while_relevant = [&, it = changes.rbegin()]
     69                                   (const BufferCoord& pos) mutable {
     70         while (it != changes.rend())
     71         {
     72             const Buffer::Change change{it->type,
     73                                         changes_tracker.get_new_coord(it->begin),
     74                                         changes_tracker.get_new_coord(it->end)};
     75             if (not changes_tracker.relevant(change, pos))
     76                 break;
     77             changes_tracker.update(change);
     78             ++it;
     79         }
     80     };
     81 
     82     for (auto& range : ranges)
     83         update_range(changes_tracker, range, advance_while_relevant);
     84 }
     85 
     86 template<typename RangeContainer>
     87 void update_ranges(Buffer& buffer, size_t timestamp, RangeContainer&& ranges)
     88 {
     89     if (timestamp == buffer.timestamp())
     90         return;
     91 
     92     auto changes = buffer.changes_since(timestamp);
     93     for (auto change_it = changes.begin(); change_it != changes.end(); )
     94     {
     95         auto forward_end = forward_sorted_until(change_it, changes.end());
     96         auto backward_end = backward_sorted_until(change_it, changes.end());
     97 
     98         if (forward_end >= backward_end)
     99         {
    100             update_forward({ change_it, forward_end }, ranges);
    101             change_it = forward_end;
    102         }
    103         else
    104         {
    105             update_backward({ change_it, backward_end }, ranges);
    106             change_it = backward_end;
    107         }
    108     }
    109 }
    110 
    111 }
    112 
    113 #endif // changes_hh_INCLUDED