Differential D17441 Diff 47173 src/buffer/katetextblock.cpp

Changeset View

Standalone View

View Options

src/buffer/katetextblock.cpp

Show All 15 Lines
16 * along with this library; see the file COPYING.LIB. If not, write to 16​ * along with this library; see the file COPYING.LIB. If not, write to
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 17​ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA. 18​ * Boston, MA 02110-1301, USA.
19 */ 19​ */
20 20​
21#include "katetextblock.h" 21​#include "katetextblock.h"
22#include "katetextbuffer.h" 22​#include "katetextbuffer.h"
23 23​
24​#include <QVarLengthArray>
25​
24namespace Kate 26​namespace Kate
25{ 27​{
26 28​
27TextBlock::TextBlock(TextBuffer *buffer, int startLine) 29​TextBlock::TextBlock(TextBuffer *buffer, int startLine)
28 : m_buffer(buffer) 30​ : m_buffer(buffer)
29 , m_startLine(startLine) 31​ , m_startLine(startLine)
30{ 32​{
31 // reserve the block size 33​ // reserve the block size
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Line(s)94{
144 // no cursors will leave or join this block 146​ // no cursors will leave or join this block
145 147​
146 // no cursors in this block, no work to do.. 148​ // no cursors in this block, no work to do..
147 if (m_cursors.empty()) { 149​ if (m_cursors.empty()) {
148 return; 150​ return;
149 } 151​ }
150 152​
151 // move all cursors on the line which has the text inserted 153​ // move all cursors on the line which has the text inserted
152 // remember all ranges modified 154​ // remember all ranges modified, optimize for the standard case of a few ranges
153 QSet<TextRange *> changedRanges; 155​ QVarLengthArray<TextRange *, 32> changedRanges;
anthonyfieroniUnsubmitted
Done

You can use unordered_set, so you don't need m_isCheckValidityRequired any more. It can be applied to other places as well.

anthonyfieroni: You can use unordered_set, so you don't need m_isCheckValidityRequired any more. It can be…
cullmannAuthorUnsubmitted
Done

Actually no, that will be again a lot more expensive.
With the vector, you get one allocation in many cases, with unordered_set a lot, like with QSet.
But I tend to move that to QVarLengthArray to avoid allocations at all for the normal case of << 32 cursors.

cullmann: Actually no, that will be again a lot more expensive. With the vector, you get one allocation…
154 foreach (TextCursor *cursor, m_cursors) { 156​ foreach (TextCursor *cursor, m_cursors) {
155 // skip cursors on lines in front of the wrapped one! 157​ // skip cursors on lines in front of the wrapped one!
156 if (cursor->lineInBlock() < line) { 158​ if (cursor->lineInBlock() < line) {
157 continue; 159​ continue;
158 } 160​ }
159 161​
160 // either this is simple, line behind the wrapped one 162​ // either this is simple, line behind the wrapped one
161 if (cursor->lineInBlock() > line) { 163​ if (cursor->lineInBlock() > line) {
Show All 16 Lines169 else {
178 cursor->m_line++; 180​ cursor->m_line++;
179 181​
180 // patch column 182​ // patch column
181 cursor->m_column -= position.column(); 183​ cursor->m_column -= position.column();
182 } 184​ }
183 185​
184 // remember range, if any 186​ // remember range, if any
185 if (cursor->kateRange()) { 187​ if (cursor->kateRange()) {
186 changedRanges.insert(cursor->kateRange()); 188​ cursor->kateRange()->setValidityCheckRequired();
189​ changedRanges.push_back(cursor->kateRange());
187 } 190​ }
188 } 191​ }
189 192​
190 // check validity of all ranges, might invalidate them... 193​ // we might need to invalidate ranges or notify about their changes
191 foreach (TextRange *range, changedRanges) { 194​ for (TextRange *range : changedRanges) {
195​ if (range->isValidityCheckRequired()) {
192 range->checkValidity(); 196​ range->checkValidity();
193 } 197​ }
194} 198​ }
199​}
195 200​
196void TextBlock::unwrapLine(int line, TextBlock *previousBlock, int fixStartLinesStartIndex) 201​void TextBlock::unwrapLine(int line, TextBlock *previousBlock, int fixStartLinesStartIndex)
197{ 202​{
198 // calc internal line 203​ // calc internal line
199 line = line - startLine(); 204​ line = line - startLine();
200 205​
201 // two possiblities: either first line of this block or later line 206​ // two possiblities: either first line of this block or later line
202 if (line == 0) { 207​ if (line == 0) {
Show All 37 Lines
240 */ 245​ */
241 246​
242 // no cursors in this block and the previous one, no work to do.. 247​ // no cursors in this block and the previous one, no work to do..
243 if (m_cursors.empty() && previousBlock->m_cursors.empty()) { 248​ if (m_cursors.empty() && previousBlock->m_cursors.empty()) {
244 return; 249​ return;
245 } 250​ }
246 251​
247 // move all cursors because of the unwrapped line 252​ // move all cursors because of the unwrapped line
248 // remember all ranges modified 253​ // remember all ranges modified, optimize for the standard case of a few ranges
249 QSet<TextRange *> changedRanges; 254​ QVarLengthArray<TextRange *, 32> changedRanges;
250 foreach (TextCursor *cursor, m_cursors) { 255​ foreach (TextCursor *cursor, m_cursors) {
251 // this is the unwrapped line 256​ // this is the unwrapped line
252 if (cursor->lineInBlock() == 0) { 257​ if (cursor->lineInBlock() == 0) {
253 // patch column 258​ // patch column
254 cursor->m_column += oldSizeOfPreviousLine; 259​ cursor->m_column += oldSizeOfPreviousLine;
255 260​
256 // remember range, if any 261​ // remember range, if any
257 if (cursor->kateRange()) { 262​ if (cursor->kateRange()) {
258 changedRanges.insert(cursor->kateRange()); 263​ cursor->kateRange()->setValidityCheckRequired();
264​ changedRanges.push_back(cursor->kateRange());
259 } 265​ }
260 } 266​ }
261 } 267​ }
262 268​
263 // move cursors of the moved line from previous block to this block now 269​ // move cursors of the moved line from previous block to this block now
264 QSet<TextCursor *> newPreviousCursors; 270​ QSet<TextCursor *> newPreviousCursors;
265 foreach (TextCursor *cursor, previousBlock->m_cursors) { 271​ foreach (TextCursor *cursor, previousBlock->m_cursors) {
266 if (cursor->lineInBlock() == lastLineOfPreviousBlock) { 272​ if (cursor->lineInBlock() == lastLineOfPreviousBlock) {
267 cursor->m_line = 0; 273​ cursor->m_line = 0;
268 cursor->m_block = this; 274​ cursor->m_block = this;
269 m_cursors.insert(cursor); 275​ m_cursors.insert(cursor);
270 276​
271 // remember range, if any 277​ // remember range, if any
272 if (cursor->kateRange()) { 278​ if (cursor->kateRange()) {
273 changedRanges.insert(cursor->kateRange()); 279​ cursor->kateRange()->setValidityCheckRequired();
280​ changedRanges.push_back(cursor->kateRange());
274 } 281​ }
275 } else { 282​ } else {
276 newPreviousCursors.insert(cursor); 283​ newPreviousCursors.insert(cursor);
277 } 284​ }
278 } 285​ }
279 previousBlock->m_cursors = newPreviousCursors; 286​ previousBlock->m_cursors = newPreviousCursors;
280 287​
281 // fixup the ranges that might be effected, because they moved from last line to this block 288​ // fixup the ranges that might be effected, because they moved from last line to this block
282 foreach (TextRange *range, changedRanges) { 289​ // we might need to invalidate ranges or notify about their changes
290​ for (TextRange *range : changedRanges) {
cullmannAuthorUnsubmitted
Done

This loop now crash in the unit test

./bin/bug313759

)

It works again, if I use a QSet, at that one location.
I think this is some ordering issue, funny.
Need to investigate.

cullmann: This loop now crash in the unit test ./bin/bug313759 =) It works again, if I use a QSet, at…
cullmannAuthorUnsubmitted
Done

Ok, doesn't work due to the issue that we might delete the range via notifier in checkValidity() :P

cullmann: Ok, doesn't work due to the issue that we might delete the range via notifier in checkValidity…
loh.tarUnsubmitted
Not Done

Noob question: Would QPointer help?

if (range && range->isValidityCheckRequired()) {
loh.tar: Noob question: Would QPointer help? if (range && range->isValidityCheckRequired()) {
cullmannAuthorUnsubmitted
Not Done

As it is no QObject, no ;=) Actually, I think all workaround might be even more expensive than the QSet.

cullmann: As it is no QObject, no ;=) Actually, I think all workaround might be even more expensive than…
291​ if (range->isValidityCheckRequired()) {
283 // update both blocks 292​ // update both blocks
284 updateRange(range); 293​ updateRange(range);
285 previousBlock->updateRange(range); 294​ previousBlock->updateRange(range);
286 } ​
287 295​
288 // check validity of all ranges, might invalidate them... 296​ // afterwards check validity
289 foreach (TextRange *range, changedRanges) { ​
290 range->checkValidity(); 297​ range->checkValidity();
291 } 298​ }
299​ }
292 300​
293 // be done 301​ // be done
294 return; 302​ return;
295 } 303​ }
296 304​
297 // easy: just move text to previous line and remove current one 305​ // easy: just move text to previous line and remove current one
298 const int oldSizeOfPreviousLine = m_lines.at(line - 1)->length(); 306​ const int oldSizeOfPreviousLine = m_lines.at(line - 1)->length();
299 const int sizeOfCurrentLine = m_lines.at(line)->length(); 307​ const int sizeOfCurrentLine = m_lines.at(line)->length();
Show All 27 Lines
327 */ 335​ */
328 336​
329 // no cursors in this block, no work to do.. 337​ // no cursors in this block, no work to do..
330 if (m_cursors.empty()) { 338​ if (m_cursors.empty()) {
331 return; 339​ return;
332 } 340​ }
333 341​
334 // move all cursors because of the unwrapped line 342​ // move all cursors because of the unwrapped line
335 // remember all ranges modified 343​ // remember all ranges modified, optimize for the standard case of a few ranges
336 QSet<TextRange *> changedRanges; 344​ QVarLengthArray<TextRange *, 32> changedRanges;
337 foreach (TextCursor *cursor, m_cursors) { 345​ foreach (TextCursor *cursor, m_cursors) {
338 // skip cursors in lines in front of removed one 346​ // skip cursors in lines in front of removed one
339 if (cursor->lineInBlock() < line) { 347​ if (cursor->lineInBlock() < line) {
340 continue; 348​ continue;
341 } 349​ }
342 350​
343 // this is the unwrapped line 351​ // this is the unwrapped line
344 if (cursor->lineInBlock() == line) { 352​ if (cursor->lineInBlock() == line) {
345 // patch column 353​ // patch column
346 cursor->m_column += oldSizeOfPreviousLine; 354​ cursor->m_column += oldSizeOfPreviousLine;
347 } 355​ }
348 356​
349 // patch line of cursor 357​ // patch line of cursor
350 cursor->m_line--; 358​ cursor->m_line--;
351 359​
352 // remember range, if any 360​ // remember range, if any
353 if (cursor->kateRange()) { 361​ if (cursor->kateRange()) {
354 changedRanges.insert(cursor->kateRange()); 362​ cursor->kateRange()->setValidityCheckRequired();
363​ changedRanges.push_back(cursor->kateRange());
355 } 364​ }
356 } 365​ }
357 366​
358 // check validity of all ranges, might invalidate them... 367​ // we might need to invalidate ranges or notify about their changes
359 foreach (TextRange *range, changedRanges) { 368​ for (TextRange *range : changedRanges) {
369​ if (range->isValidityCheckRequired()) {
360 range->checkValidity(); 370​ range->checkValidity();
361 } 371​ }
362} 372​ }
373​}
363 374​
364void TextBlock::insertText(const KTextEditor::Cursor &position, const QString &text) 375​void TextBlock::insertText(const KTextEditor::Cursor &position, const QString &text)
365{ 376​{
366 // calc internal line 377​ // calc internal line
367 int line = position.line() - startLine(); 378​ int line = position.line() - startLine();
368 379​
369 // get text 380​ // get text
370 QString &textOfLine = m_lines.at(line)->textReadWrite(); 381​ QString &textOfLine = m_lines.at(line)->textReadWrite();
Show All 17 Lines
388 */ 399​ */
389 400​
390 // no cursors in this block, no work to do.. 401​ // no cursors in this block, no work to do..
391 if (m_cursors.empty()) { 402​ if (m_cursors.empty()) {
392 return; 403​ return;
393 } 404​ }
394 405​
395 // move all cursors on the line which has the text inserted 406​ // move all cursors on the line which has the text inserted
396 // remember all ranges modified 407​ // remember all ranges modified, optimize for the standard case of a few ranges
397 QSet<TextRange *> changedRanges; 408​ QVarLengthArray<TextRange *, 32> changedRanges;
398 foreach (TextCursor *cursor, m_cursors) { 409​ foreach (TextCursor *cursor, m_cursors) {
399 // skip cursors not on this line! 410​ // skip cursors not on this line!
400 if (cursor->lineInBlock() != line) { 411​ if (cursor->lineInBlock() != line) {
401 continue; 412​ continue;
402 } 413​ }
403 414​
404 // skip cursors with too small column 415​ // skip cursors with too small column
405 if (cursor->column() <= position.column()) { 416​ if (cursor->column() <= position.column()) {
406 if (cursor->column() < position.column() || !cursor->m_moveOnInsert) { 417​ if (cursor->column() < position.column() || !cursor->m_moveOnInsert) {
407 continue; 418​ continue;
408 } 419​ }
409 } 420​ }
410 421​
411 // patch column of cursor 422​ // patch column of cursor
412 if (cursor->m_column <= oldLength) { 423​ if (cursor->m_column <= oldLength) {
413 cursor->m_column += text.size(); 424​ cursor->m_column += text.size();
414 } 425​ }
415 426​
416 // special handling if cursor behind the real line, e.g. non-wrapping cursor in block selection mode 427​ // special handling if cursor behind the real line, e.g. non-wrapping cursor in block selection mode
417 else if (cursor->m_column < textOfLine.size()) { 428​ else if (cursor->m_column < textOfLine.size()) {
418 cursor->m_column = textOfLine.size(); 429​ cursor->m_column = textOfLine.size();
419 } 430​ }
420 431​
421 // remember range, if any 432​ // we only need to trigger checkValidity later if the range has feedback or might be invalidated
422 if (cursor->kateRange()) { 433​ if (cursor->kateRange() && (cursor->kateRange()->feedback() || cursor->kateRange()->start().line() == cursor->kateRange()->end().line())) {
423 changedRanges.insert(cursor->kateRange()); 434​ cursor->kateRange()->setValidityCheckRequired();
435​ changedRanges.push_back(cursor->kateRange());
424 } 436​ }
425 } 437​ }
426 438​
427 // check validity of all ranges, might invalidate them... 439​ // we might need to invalidate ranges or notify about their changes
428 foreach (TextRange *range, changedRanges) { 440​ for (TextRange *range : changedRanges) {
441​ if (range->isValidityCheckRequired()) {
429 range->checkValidity(); 442​ range->checkValidity();
430 } 443​ }
431} 444​ }
445​}
432 446​
433void TextBlock::removeText(const KTextEditor::Range &range, QString &removedText) 447​void TextBlock::removeText(const KTextEditor::Range &range, QString &removedText)
434{ 448​{
435 // calc internal line 449​ // calc internal line
436 int line = range.start().line() - startLine(); 450​ int line = range.start().line() - startLine();
437 451​
438 // get text 452​ // get text
439 QString &textOfLine = m_lines.at(line)->textReadWrite(); 453​ QString &textOfLine = m_lines.at(line)->textReadWrite();
Show All 22 Lines
462 */ 476​ */
463 477​
464 // no cursors in this block, no work to do.. 478​ // no cursors in this block, no work to do..
465 if (m_cursors.empty()) { 479​ if (m_cursors.empty()) {
466 return; 480​ return;
467 } 481​ }
468 482​
469 // move all cursors on the line which has the text removed 483​ // move all cursors on the line which has the text removed
470 // remember all ranges modified 484​ // remember all ranges modified, optimize for the standard case of a few ranges
471 QSet<TextRange *> changedRanges; 485​ QVarLengthArray<TextRange *, 32> changedRanges;
472 foreach (TextCursor *cursor, m_cursors) { 486​ foreach (TextCursor *cursor, m_cursors) {
473 // skip cursors not on this line! 487​ // skip cursors not on this line!
474 if (cursor->lineInBlock() != line) { 488​ if (cursor->lineInBlock() != line) {
475 continue; 489​ continue;
476 } 490​ }
477 491​
478 // skip cursors with too small column 492​ // skip cursors with too small column
479 if (cursor->column() <= range.start().column()) { 493​ if (cursor->column() <= range.start().column()) {
480 continue; 494​ continue;
481 } 495​ }
482 496​
483 // patch column of cursor 497​ // patch column of cursor
484 if (cursor->column() <= range.end().column()) { 498​ if (cursor->column() <= range.end().column()) {
485 cursor->m_column = range.start().column(); 499​ cursor->m_column = range.start().column();
486 } else { 500​ } else {
487 cursor->m_column -= (range.end().column() - range.start().column()); 501​ cursor->m_column -= (range.end().column() - range.start().column());
488 } 502​ }
489 503​
490 // remember range, if any 504​ // we only need to trigger checkValidity later if the range has feedback or might be invalidated
491 if (cursor->kateRange()) { 505​ if (cursor->kateRange() && (cursor->kateRange()->feedback() || cursor->kateRange()->start().line() == cursor->kateRange()->end().line())) {
492 changedRanges.insert(cursor->kateRange()); 506​ cursor->kateRange()->setValidityCheckRequired();
507​ changedRanges.push_back(cursor->kateRange());
493 } 508​ }
494 } 509​ }
495 510​
496 // check validity of all ranges, might invalidate them... 511​ // we might need to invalidate ranges or notify about their changes
497 foreach (TextRange *range, changedRanges) { 512​ for (TextRange *range : changedRanges) {
513​ if (range->isValidityCheckRequired()) {
498 range->checkValidity(); 514​ range->checkValidity();
499 } 515​ }
500} 516​ }
517​}
501 518​
502void TextBlock::debugPrint(int blockIndex) const 519​void TextBlock::debugPrint(int blockIndex) const
503{ 520​{
504 // print all blocks 521​ // print all blocks
505 for (int i = 0; i < m_lines.size(); ++i) 522​ for (int i = 0; i < m_lines.size(); ++i)
506 printf("%4d - %4d : %4d : '%s'\n", blockIndex, startLine() + i 523​ printf("%4d - %4d : %4d : '%s'\n", blockIndex, startLine() + i
507 , m_lines.at(i)->text().size(), qPrintable(m_lines.at(i)->text())); 524​ , m_lines.at(i)->text().size(), qPrintable(m_lines.at(i)->text()));
508} 525​}
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines