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
162
|
#ifndef selection_hh_INCLUDED
#define selection_hh_INCLUDED
#include "buffer.hh"
namespace Kakoune
{
using CaptureList = Vector<String, MemoryDomain::Selections>;
// A selection is a Selection, associated with a CaptureList
struct Selection
{
static constexpr MemoryDomain Domain = MemoryDomain::Selections;
Selection() = default;
Selection(BufferCoord pos) : Selection(pos,pos) {}
Selection(BufferCoord anchor, BufferCoord cursor,
CaptureList captures = {})
: m_anchor{anchor}, m_cursor{cursor},
m_captures(std::move(captures)) {}
BufferCoord& anchor() { return m_anchor; }
BufferCoordAndTarget& cursor() { return m_cursor; }
const BufferCoord& anchor() const { return m_anchor; }
const BufferCoordAndTarget& cursor() const { return m_cursor; }
void set(BufferCoord anchor, BufferCoord cursor)
{
m_anchor = anchor;
m_cursor = cursor;
}
void set(BufferCoord coord) { set(coord, coord); }
CaptureList& captures() { return m_captures; }
const CaptureList& captures() const { return m_captures; }
bool operator== (const Selection& other) const
{
return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
}
// When selections are single char, we want the anchor to be considered min, and cursor max
const BufferCoord& min() const { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
const BufferCoord& max() const { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
private:
BufferCoord m_anchor;
BufferCoordAndTarget m_cursor;
CaptureList m_captures;
};
inline bool overlaps(const Selection& lhs, const Selection& rhs)
{
return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
: lhs.min() <= rhs.max();
}
void update_selections(Vector<Selection>& selections, size_t& main,
Buffer& buffer, size_t timestamp);
enum class InsertMode : unsigned
{
Insert,
InsertCursor,
Append,
Replace,
InsertAtLineBegin,
InsertAtNextLineBegin,
AppendAtLineEnd,
OpenLineBelow,
OpenLineAbove
};
struct SelectionList
{
static constexpr MemoryDomain Domain = MemoryDomain::Selections;
SelectionList(Buffer& buffer, Selection s);
SelectionList(Buffer& buffer, Selection s, size_t timestamp);
SelectionList(Buffer& buffer, Vector<Selection> s);
SelectionList(Buffer& buffer, Vector<Selection> s, size_t timestamp);
struct UnsortedTag {};
SelectionList(UnsortedTag, Buffer& buffer, Vector<Selection> s);
SelectionList(UnsortedTag, Buffer& buffer, Vector<Selection> s, size_t timestamp);
void update();
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 push_back(const Selection& sel) { m_selections.push_back(sel); }
void push_back(Selection&& sel) { m_selections.push_back(std::move(sel)); }
Selection& operator[](size_t i) { return m_selections[i]; }
const Selection& operator[](size_t i) const { return m_selections[i]; }
void set(Vector<Selection> list, size_t main);
SelectionList& operator=(Vector<Selection> list)
{
const size_t main_index = list.size()-1;
set(std::move(list), main_index);
return *this;
}
using iterator = Vector<Selection>::iterator;
iterator begin() { return m_selections.begin(); }
iterator end() { return m_selections.end(); }
using const_iterator = Vector<Selection>::const_iterator;
const_iterator begin() const { return m_selections.begin(); }
const_iterator end() const { return m_selections.end(); }
void remove(size_t index);
size_t size() const { return m_selections.size(); }
bool operator==(const SelectionList& other) const { return m_buffer == other.m_buffer and m_selections == other.m_selections; }
bool operator!=(const SelectionList& other) const { return not ((*this) == other); }
void sort();
void merge_overlapping();
void merge_consecutive();
void sort_and_merge_overlapping();
Buffer& buffer() const { return *m_buffer; }
size_t timestamp() const { return m_timestamp; }
void insert(ConstArrayView<String> strings, InsertMode mode,
Vector<BufferCoord>* out_insert_pos = nullptr);
void erase();
private:
size_t m_main = 0;
Vector<Selection> m_selections;
SafePtr<Buffer> m_buffer;
size_t m_timestamp;
};
Vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp);
String selection_to_string(const Selection& selection);
String selection_list_to_string(const SelectionList& selection);
Selection selection_from_string(StringView desc);
SelectionList selection_list_from_string(Buffer& buffer, StringView desc);
}
#endif // selection_hh_INCLUDED
|
