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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/**
* Copyright (c) 2007-2012, Timothy Stack
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Timothy Stack nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* @file bookmarks.hh
*/
#ifndef bookmarks_hh
#define bookmarks_hh
#include <algorithm>
#include <map>
#include <unordered_set>
#include <string>
#include <vector>
#include "base/lnav_log.hh"
struct bookmark_metadata {
static std::unordered_set<std::string> KNOWN_TAGS;
std::string bm_name;
std::string bm_comment;
std::vector<std::string> bm_tags;
void add_tag(const std::string& tag);
bool remove_tag(const std::string& tag);
bool empty() const;
void clear();
};
/**
* Extension of the STL vector that is used to store bookmarks for
* files being viewed, where a bookmark is just a particular line in
* the file(s). The value-added over the standard vector are some
* methods for doing content-wise iteration. In other words, given a
* value that may or may not be in the vector, find the next or
* previous value that is in the vector.
*
* @param LineType The type used to store line numbers. (e.g.
* vis_line_t or content_line_t)
*
* @note The vector is expected to be sorted.
*/
template<typename LineType>
class bookmark_vector : public std::vector<LineType> {
using base_vector = std::vector<LineType>;
public:
using size_type = typename base_vector::size_type;
using iterator = typename base_vector::iterator;
using const_iterator = typename base_vector::const_iterator;
/**
* Insert a bookmark into this vector, but only if it is not already in the
* vector.
*
* @param vl The line to bookmark.
*/
iterator insert_once(LineType vl)
{
iterator retval;
require(vl >= 0);
auto lb = std::lower_bound(this->begin(), this->end(), vl);
if (lb == this->end() || *lb != vl) {
this->insert(lb, vl);
retval = this->end();
} else {
retval = lb;
}
return retval;
}
std::pair<iterator, iterator> equal_range(LineType start, LineType stop)
{
auto lb = std::lower_bound(this->begin(), this->end(), start);
if (stop == LineType(-1)) {
return std::make_pair(lb, this->end());
}
auto up = std::upper_bound(this->begin(), this->end(), stop);
return std::make_pair(lb, up);
}
/**
* @param start The value to start the search for the next bookmark.
* @return The next bookmark value in the vector or -1 if there are
* no more remaining bookmarks. If the 'start' value is a bookmark,
* the next bookmark is returned. If the 'start' value is not a
* bookmark, the next highest value in the vector is returned.
*/
nonstd::optional<LineType> next(LineType start) const;
/**
* @param start The value to start the search for the previous
* bookmark.
* @return The previous bookmark value in the vector or -1 if there
* are no more prior bookmarks.
* @see next
*/
nonstd::optional<LineType> prev(LineType start) const;
};
/**
* Dummy type whose instances are used to distinguish between
* bookmarks maintained by different source modules.
*/
class bookmark_type_t {
public:
using type_iterator = std::vector<bookmark_type_t*>::iterator;
static type_iterator type_begin() { return get_all_types().begin(); }
static type_iterator type_end() { return get_all_types().end(); }
static nonstd::optional<bookmark_type_t*> find_type(
const std::string& name);
static std::vector<bookmark_type_t*>& get_all_types();
explicit bookmark_type_t(std::string name) : bt_name(std::move(name))
{
get_all_types().push_back(this);
}
const std::string& get_name() const { return this->bt_name; }
private:
const std::string bt_name;
};
template<typename LineType>
nonstd::optional<LineType>
bookmark_vector<LineType>::next(LineType start) const
{
nonstd::optional<LineType> retval;
require(start >= -1);
auto ub = std::upper_bound(this->cbegin(), this->cend(), start);
if (ub != this->cend()) {
retval = *ub;
}
ensure(!retval || start < retval.value());
return retval;
}
template<typename LineType>
nonstd::optional<LineType>
bookmark_vector<LineType>::prev(LineType start) const
{
nonstd::optional<LineType> retval;
require(start >= 0);
auto lb = std::lower_bound(this->cbegin(), this->cend(), start);
if (lb != this->cbegin()) {
lb -= 1;
retval = *lb;
}
ensure(!retval || retval.value() < start);
return retval;
}
/**
* Map of bookmark types to bookmark vectors.
*/
template<typename LineType>
struct bookmarks {
using type = std::map<const bookmark_type_t*, bookmark_vector<LineType>>;
};
#endif
|
