1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
#ifndef selection_hh_INCLUDED
#define selection_hh_INCLUDED
#include "buffer.hh"
namespace Kakoune
{
// An oriented, inclusive buffer range
struct Range
{
public:
Range(BufferCoord first, BufferCoord last)
: m_first{first}, m_last{last} {}
void merge_with(const Range& range);
BufferCoord& first() { return m_first; }
BufferCoord& last() { return m_last; }
const BufferCoord& first() const { return m_first; }
const BufferCoord& last() const { return m_last; }
bool operator== (const Range& other) const
{
return m_first == other.m_first and m_last == other.m_last;
}
const BufferCoord& min() const { return std::min(m_first, m_last); }
const BufferCoord& max() const { return std::max(m_first, m_last); }
private:
BufferCoord m_first;
BufferCoord m_last;
};
inline bool overlaps(const Range& lhs, const Range& rhs)
{
return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
: lhs.min() <= rhs.max();
}
inline String content(const Buffer& buffer, const Range& range)
{
return buffer.string(range.min(), buffer.char_next(range.max()));
}
inline BufferIterator erase(Buffer& buffer, const Range& range)
{
return buffer.erase(buffer.iterator_at(range.min()),
utf8::next(buffer.iterator_at(range.max())));
}
inline CharCount char_length(const Buffer& buffer, const Range& range)
{
return utf8::distance(buffer.iterator_at(range.min()),
utf8::next(buffer.iterator_at(range.max())));
}
inline void avoid_eol(const Buffer& buffer, BufferCoord& coord)
{
const auto column = coord.column;
const auto& line = buffer[coord.line];
if (column != 0 and column == line.length() - 1)
coord.column = line.byte_count_to(line.char_length() - 2);
}
inline void avoid_eol(const Buffer& buffer, Range& sel)
{
avoid_eol(buffer, sel.first());
avoid_eol(buffer, sel.last());
}
using CaptureList = std::vector<String>;
// A selection is a Range, associated with a CaptureList
struct Selection : public Range
{
explicit Selection(BufferCoord pos) : Range(pos,pos) {}
Selection(BufferCoord first, BufferCoord last,
CaptureList captures = {})
: Range(first, last), m_captures(std::move(captures)) {}
Selection(const Range& range)
: Range(range) {}
CaptureList& captures() { return m_captures; }
const CaptureList& captures() const { return m_captures; }
private:
CaptureList m_captures;
};
static bool compare_selections(const Selection& lhs, const Selection& rhs)
{
return lhs.min() < rhs.min();
}
struct SelectionList : std::vector<Selection>
{
SelectionList() = default;
SelectionList(BufferCoord c) : std::vector<Selection>{Selection{c,c}} {}
SelectionList(Selection s) : std::vector<Selection>{s} {}
void update_insert(const Buffer& buffer, BufferCoord begin, BufferCoord end);
void update_erase(const Buffer& buffer, BufferCoord begin, BufferCoord end);
void check_invariant() const;
const Selection& main() const { return (*this)[m_main]; }
Selection& main() { return (*this)[m_main]; }
size_t main_index() const { return m_main; }
void set_main_index(size_t main) { kak_assert(main < size()); m_main = main; }
void rotate_main(int count) { m_main = (m_main + count) % size(); }
template<typename OverlapsFunc>
void merge_overlapping(OverlapsFunc overlaps)
{
kak_assert(std::is_sorted(begin(), end(), compare_selections));
for (size_t i = 0; i+1 < size() and size() > 1;)
{
if (overlaps((*this)[i], (*this)[i+1]))
{
(*this)[i].merge_with((*this)[i+1]);
erase(begin() + i + 1);
if (i + 1 <= m_main)
--m_main;
}
else
++i;
}
}
void sort_and_merge_overlapping()
{
if (size() == 1)
return;
const auto& main = this->main();
const auto main_begin = main.min();
m_main = std::count_if(begin(), end(), [&](const Selection& sel) {
auto begin = sel.min();
if (begin == main_begin)
return &sel < &main;
else
return begin < main_begin;
});
std::stable_sort(begin(), end(), compare_selections);
merge_overlapping(overlaps);
}
private:
size_t m_main = 0;
};
}
#endif // selection_hh_INCLUDED
|
