Merge pull request #20 from devmil/feature/improve_line_manipulation_performance

improve line manipulation performance

lib/buffer/buffer.dart

@@ -3,6 +3,7 @@ import 'dart:math' show max, min;
 import 'package:xterm/buffer/buffer_line.dart';
 import 'package:xterm/terminal/charset.dart';
 import 'package:xterm/terminal/terminal.dart';
+import 'package:xterm/utli/circular_list.dart';
 import 'package:xterm/utli/scroll_range.dart';
 import 'package:xterm/utli/unicode_v11.dart';
 
@@ -10,10 +11,12 @@ class Buffer {
   Buffer(this.terminal) {
     resetVerticalMargins();
 
-    lines = List.generate(
-      terminal.viewHeight,
-      (_) => _newEmptyLine(),
+    lines = CircularList(
+      terminal.maxLines,
     );
+    for (int i = 0; i < terminal.viewHeight; i++) {
+      lines.push(_newEmptyLine());
+    }
   }
 
   final Terminal terminal;
@@ -21,7 +24,7 @@ class Buffer {
 
   /// lines of the buffer. the length of [lines] should always be equal or
   /// greater than [Terminal.viewHeight].
-  late final List<BufferLine> lines;
+  late final CircularList<BufferLine> lines;
 
   int? _savedCursorX;
   int? _savedCursorY;
@@ -269,18 +272,12 @@ class Buffer {
     // the cursor is not in the scrollable region
     if (_cursorY >= terminal.viewHeight - 1) {
       // we are at the bottom so a new line is created.
-      lines.add(_newEmptyLine());
+      lines.push(_newEmptyLine());
 
       // keep viewport from moving if user is scrolling.
       if (isUserScrolling) {
         _scrollOffsetFromBottom++;
       }
-
-      // clean extra lines if needed.
-      final maxLines = terminal.maxLines;
-      if (maxLines != null && lines.length > maxLines) {
-        lines.removeRange(0, lines.length - maxLines);
-      }
     } else {
       // there're still lines so we simply move cursor down.
       moveCursorY(1);
@@ -419,16 +416,14 @@ class Buffer {
       return;
     }
 
-    lines.removeRange(0, lines.length - terminal.viewHeight);
+    lines.trimStart(lines.length - terminal.viewHeight);
   }
 
   void clear() {
     lines.clear();
-
-    lines.addAll(List.generate(
-      terminal.viewHeight,
-      (_) => _newEmptyLine(),
-    ));
+    for (int i = 0; i < terminal.viewHeight; i++) {
+      lines.push(_newEmptyLine());
+    }
   }
 
   void insertBlankCharacters(int count) {
@@ -455,19 +450,9 @@ class Buffer {
       final index = convertViewLineToRawLine(_cursorX);
       final newLine = _newEmptyLine();
       lines.insert(index, newLine);
-
-      final maxLines = terminal.maxLines;
-      if (maxLines != null && lines.length > maxLines) {
-        lines.removeRange(0, lines.length - maxLines);
-      }
     } else {
-      final bottom = convertViewLineToRawLine(marginBottom);
-
-      final movedLines = lines.getRange(_cursorY, bottom - 1);
-      lines.setRange(_cursorY + 1, bottom, movedLines);
-
       final newLine = _newEmptyLine();
-      lines[_cursorY] = newLine;
+      lines.insert(_cursorY, newLine);
     }
   }
 
@@ -490,21 +475,21 @@ class Buffer {
       return;
     }
 
-    lines.removeAt(index);
+    lines.remove(index);
   }
 
   void resize(int newWidth, int newHeight) {
     if (newWidth > terminal.viewWidth) {
-      for (var line in lines) {
+      lines.forEach((line) {
         line.ensure(newWidth);
-      }
+      });
     }
 
     if (newHeight > terminal.viewHeight) {
       // Grow larger
       for (var i = 0; i < newHeight - terminal.viewHeight; i++) {
         if (_cursorY < terminal.viewHeight - 1) {
-          lines.add(_newEmptyLine());
+          lines.push(_newEmptyLine());
         } else {
           _cursorY++;
         }
@@ -513,7 +498,7 @@ class Buffer {
       // Shrink smaller
       for (var i = 0; i < terminal.viewHeight - newHeight; i++) {
         if (_cursorY < terminal.viewHeight - 1) {
-          lines.removeLast();
+          lines.pop();
         } else {
           _cursorY++;
         }

lib/buffer/buffer_line.dart

@@ -85,7 +85,7 @@ class BufferLine {
   }
 
   void clear() {
-    _cells.buffer.asInt64List().clear();
+    removeRange(0, _cells.lengthInBytes ~/ _cellSize);
   }
 
   void erase(Cursor cursor, int start, int end) {

lib/terminal/terminal.dart

@@ -38,10 +38,8 @@ class Terminal with Observable {
     this.onIconChange = _defaultIconHandler,
     this.platform = PlatformBehaviors.unix,
     this.theme = TerminalThemes.defaultTheme,
-    int? maxLines,
-  }) {
-    _maxLines = maxLines;
-
+    required int maxLines,
+  }) : _maxLines = maxLines {
     _mainBuffer = Buffer(this);
     _altBuffer = Buffer(this);
     _buffer = _mainBuffer;
@@ -65,10 +63,9 @@ class Terminal with Observable {
     }
   }
 
-  int? _maxLines;
-  int? get maxLines {
-    if (_maxLines == null) return null;
-    return max(viewHeight, _maxLines!);
+  int _maxLines;
+  int get maxLines {
+    return max(viewHeight, _maxLines);
   }
 
   int _viewWidth = 80;

lib/utli/circular_list.dart

@@ -0,0 +1,175 @@
+class CircularList<T> {
+  CircularList(int maxLength) : _array = List<T?>.filled(maxLength, null);
+
+  late List<T?> _array;
+  var _length = 0;
+  var _startIndex = 0;
+
+  // Gets the cyclic index for the specified regular index. The cyclic index can then be used on the
+  // backing array to get the element associated with the regular index.
+  int _getCyclicIndex(int index) {
+    return (_startIndex + index) % _array.length;
+  }
+
+  int get maxLength {
+    return _array.length;
+  }
+
+  set maxLength(int value) {
+    if (value <= 0)
+      throw ArgumentError.value(
+          value, 'value', 'maxLength can\'t be negative!');
+
+    if (value == _array.length) return;
+
+    // Reconstruct array, starting at index 0. Only transfer values from the
+    // indexes 0 to length.
+    final newArray = List<T?>.generate(
+      value,
+      (index) => index < _array.length ? _array[_getCyclicIndex(index)] : null,
+    );
+
+    _startIndex = 0;
+    _array = newArray;
+  }
+
+  int get length {
+    return _length;
+  }
+
+  set length(int value) {
+    if (value > _length) {
+      for (int i = length; i < value; i++) {
+        _array[i] = null;
+      }
+    }
+    _length = value;
+  }
+
+  void forEach(void Function(T item) callback) {
+    final length = _length;
+    for (int i = 0; i < length; i++) {
+      callback(_array[_getCyclicIndex(i)]!);
+    }
+  }
+
+  T operator [](int index) {
+    if (index >= length) {
+      throw RangeError.range(index, 0, length - 1);
+    }
+
+    return _array[_getCyclicIndex(index)]!;
+  }
+
+  operator []=(int index, T value) {
+    if (index >= length) {
+      throw RangeError.range(index, 0, length - 1);
+    }
+
+    _array[_getCyclicIndex(index)] = value;
+  }
+
+  void clear() {
+    _startIndex = 0;
+    _length = 0;
+  }
+
+  void push(T value) {
+    _array[_getCyclicIndex(_length)] = value;
+    if (_length == _array.length) {
+      _startIndex++;
+      if (_startIndex == _array.length) {
+        _startIndex = 0;
+      }
+    } else {
+      _length++;
+    }
+  }
+
+  /// Removes and returns the last value on the list
+  T pop() {
+    return _array[_getCyclicIndex(_length-- - 1)]!;
+  }
+
+  /// Deletes item at [index].
+  void remove(int index, [int count = 1]) {
+    if (count > 0) {
+      for (var i = index; i < _length - count; i++) {
+        _array[_getCyclicIndex(i)] = _array[_getCyclicIndex(i + count)];
+      }
+      length -= count;
+    }
+  }
+
+  /// Inserts [item] at [index].
+  void insert(int index, T item) {
+    for (var i = _length - 1; i >= index; i--) {
+      _array[_getCyclicIndex(i + 1)] = _array[_getCyclicIndex(i)];
+    }
+
+    _array[_getCyclicIndex(index)] = item;
+
+    if (_length + 1 > _array.length) {
+      _startIndex += 1;
+    } else {
+      _length++;
+    }
+  }
+
+  /// Inserts [items] at [index] in order.
+  void insertAll(int index, List<T> items) {
+    for (var i = _length - 1; i >= index; i--) {
+      _array[_getCyclicIndex(i + 1)] = _array[_getCyclicIndex(i)];
+    }
+
+    for (var i = 0; i < items.length; i++) {
+      _array[_getCyclicIndex(index + i)] = items[i];
+    }
+
+    if (_length + items.length > _array.length) {
+      final countToTrim = _length + items.length - _array.length;
+      _startIndex += countToTrim;
+      length = _array.length;
+    } else {
+      _length += items.length;
+    }
+  }
+
+  void trimStart(int count) {
+    if (count > _length) count = _length;
+    _startIndex += count;
+    _startIndex %= _array.length;
+    _length -= count;
+  }
+
+  void shiftElements(int start, int count, int offset) {
+    if (count < 0) return;
+    if (start < 0 || start >= _length)
+      throw Exception('Start argument is out of range');
+    if (start + offset < 0)
+      throw Exception('Can not shift elements in list beyond index 0');
+    if (offset > 0) {
+      for (var i = count - 1; i >= 0; i--) {
+        this[start + i + offset] = this[start + i];
+      }
+      var expandListBy = (start + count + offset) - _length;
+      if (expandListBy > 0) {
+        _length += expandListBy;
+        while (_length > _array.length) {
+          length--;
+          _startIndex++;
+        }
+      }
+    } else {
+      for (var i = 0; i < count; i++) {
+        this[start + i + offset] = this[start + i];
+      }
+    }
+  }
+
+  bool get isFull => length == maxLength;
+
+  List<T> toList() {
+    return List<T>.generate(length, (index) => this[index]);
+  }
+}