Files
LN-Code-Editor/packages/re_editor/lib/src/code_lines.dart
T
2026-09-14 00:06:49 +08:00

461 lines
11 KiB
Dart

part of re_editor;
const int _kCodeLineSegamentDefaultSize = 256;
class CodeLines {
final List<CodeLineSegment> segments;
const CodeLines(this.segments);
factory CodeLines.empty() {
return CodeLines.of([]);
}
factory CodeLines.fromText(String text) {
return text.codeLines;
}
factory CodeLines.from(CodeLines codeLines) {
final List<CodeLineSegment> segments = [];
for (final CodeLineSegment segment in codeLines.segments) {
if (segment.isEmpty) {
continue;
}
segments.add(segment.copyWith(
dirty: true
));
}
return CodeLines(segments);
}
factory CodeLines.of(Iterable<CodeLine> elements) {
final List<CodeLineSegment> segments = [];
int count = 0;
for (int i = 0; i < elements.length; i++) {
if (count == 0) {
segments.add(CodeLineSegment.of(codeLines: []));
}
segments.last.add(elements.elementAt(i));
count++;
if (count >= _kCodeLineSegamentDefaultSize) {
count = 0;
}
}
return CodeLines(segments);
}
CodeLine get first => segments.first.first;
CodeLine get last => segments.last.last;
int get length => segments.fold(0, (previousValue, element) => previousValue += element.length);
bool get isEmpty => segments.isEmpty || length == 0;
bool get isNotEmpty => !isEmpty;
int get lineCount => segments.fold(0, (previousValue, element) => previousValue += element.lineCount);
CodeLine operator [](int index) {
int offset = 0;
for (final CodeLineSegment segment in segments) {
if (index - offset >= segment.length) {
offset += segment.length;
} else {
return segment[index - offset];
}
}
throw RangeError.range(index, 0, length - 1);
}
void operator []=(int index, CodeLine value) {
int offset = 0;
for (int i = 0; i < segments.length; i++) {
CodeLineSegment segment = segments[i];
if (index - offset >= segment.length) {
offset += segment.length;
} else {
if (segment.dirty) {
segment = segment.clone();
segments[i] = segment;
}
segment[index - offset] = value;
return;
}
}
throw RangeError.range(index, 0, length - 1);
}
void add(CodeLine value) {
if (isEmpty || segments.last.length >= _kCodeLineSegamentDefaultSize) {
segments.add(CodeLineSegment.of(
codeLines: [
value
]
));
} else {
CodeLineSegment segment = segments.last;
if (segment.dirty) {
segment = segment.clone();
segments.last = segment;
}
segment.add(value);
}
}
void addAll(Iterable<CodeLine> iterable) {
if (isEmpty) {
segments.addAll(CodeLines.of(iterable).segments);
return;
}
final CodeLineSegment segment = segments.last;
int count;
if (segment.length >= _kCodeLineSegamentDefaultSize) {
count = 0;
} else {
count = segment.length;
if (segment.dirty) {
segments.last = segment.clone();
}
}
for (int i = 0; i < iterable.length; i++) {
if (count == 0) {
segments.add(CodeLineSegment.of(codeLines: []));
}
segments.last.add(iterable.elementAt(i));
count++;
if (count >= _kCodeLineSegamentDefaultSize) {
count = 0;
}
}
}
void addFrom(CodeLines codeLines, int start, [int? end]) {
final CodeLines sub = codeLines.sublines(start, end);
if (sub.isEmpty) {
return;
}
if (isEmpty) {
segments.addAll(sub.segments);
return;
}
final List<CodeLineSegment> appendSegments = sub.segments;
for (int i = 0; i < appendSegments.length; i++) {
CodeLineSegment tail = segments.last;
final CodeLineSegment appendSegment = appendSegments[i];
if (tail.length + appendSegment.length <= _kCodeLineSegamentDefaultSize) {
if (tail.dirty) {
tail = tail.clone();
segments.last = tail;
}
tail.addAll(appendSegment);
} else {
segments.add(appendSegment);
}
}
}
bool equals(CodeLines? codeLines) {
if (codeLines == null) {
return false;
}
// Quick comparation
if (isEmpty && codeLines.isEmpty) {
return true;
}
if (isEmpty && codeLines.isNotEmpty) {
return false;
}
if (isNotEmpty && codeLines.isEmpty) {
return false;
}
if (first != codeLines.first) {
return false;
}
if (last != codeLines.last) {
return false;
}
final int length1 = length;
final int length2 = codeLines.length;
if (length1 != length2) {
return false;
}
final int minSegmentLength = min(segments.length, codeLines.segments.length);
int offset = 0;
for (int i = 0; i < minSegmentLength; i++) {
if (segments[i].length != codeLines.segments[i].length) {
break;
}
if (!listEquals(segments[i].codeLines, codeLines.segments[i].codeLines)) {
return false;
}
offset += segments[i].length;
}
// The worst is the distributions are different, we should compare them one by one
for (int i = offset; i < length1; i++) {
if (this[i] != codeLines[i]) {
return false;
}
}
return true;
}
CodeLines sublines(int start, [int? end]) {
end ??= length;
if (end > length) {
throw RangeError.range(end, 0, length - 1);
}
if (start > end) {
throw RangeError('start $start should be less than end $end');
}
if (start == end) {
return CodeLines.empty();
}
final List<CodeLineSegment> newSegments = [];
int offset = 0;
for (final CodeLineSegment segment in segments) {
if (start - offset >= segment.length) {
offset += segment.length;
continue;
}
if (start <= offset) {
if (end - offset >= segment.length) {
newSegments.add(segment.copyWith(
dirty: true
));
offset += segment.length;
continue;
} else {
if (end > offset) {
newSegments.add(segment.clone(0, end - offset));
}
break;
}
} else {
if (end - offset >= segment.length) {
newSegments.add(segment.clone(start - offset, segment.length));
offset += segment.length;
continue;
} else {
newSegments.add(segment.clone(start - offset, end - offset));
break;
}
}
}
return CodeLines(newSegments);
}
void clear() {
segments.clear();
}
String asString(TextLineBreak lineBreak, [bool expandChunks = true]) {
final StringBuffer sb = StringBuffer();
final int length = this.length;
int count = 0;
for (final CodeLineSegment segment in segments) {
for (final CodeLine codeLine in segment.codeLines) {
count++;
if (expandChunks) {
sb.write(codeLine.asString(0, lineBreak));
} else {
sb.write(codeLine.text);
}
if (count != length) {
sb.write(lineBreak.value);
}
}
}
return sb.toString();
}
int index2lineIndex(int index) {
if (index < 0 || index >= length) {
return -1;
}
int lineIndex = 0;
int offset = 0;
for (final CodeLineSegment segment in segments) {
if (index - offset >= segment.length) {
offset += segment.length;
lineIndex += segment.lineCount;
} else {
for (int j = 0; j < index - offset; j++) {
lineIndex += segment[j].lineCount;
}
break;
}
}
return lineIndex;
}
CodeLineIndex lineIndex2Index(int lineIndex) {
if (lineIndex < 0) {
return const CodeLineIndex(-1, -1);
}
// Find the segment first
int segmentIndex = -1;
int lineCount = 0;
for (int i = 0, start = 0; i < segments.length; i++) {
final int end = start + segments[i].lineCount;
if (lineIndex >= start && lineIndex < end) {
segmentIndex = i;
lineIndex -= start;
break;
}
start = end;
lineCount += segments[i].length;
}
if (segmentIndex < 0) {
return const CodeLineIndex(-1, -1);
}
// Find the index in the segment
final List<CodeLine> codeLines = segments[segmentIndex].codeLines;
int index = -1;
int start = 0;
for (int i = 0; i < codeLines.length; i++) {
final int end = start + codeLines[i].lineCount;
if (lineIndex >= start && lineIndex < end) {
index = i;
start++;
break;
}
start = end;
}
if (index == -1) {
return const CodeLineIndex(-1, -1);
}
// Find the index in the chunk
int chunkIndex = -1;
final List<CodeLine> chunks = codeLines[index].chunks;
for (int i = 0; i < chunks.length; i++) {
final int end = start + chunks[i].lineCount;
if (lineIndex >= start && lineIndex < end) {
chunkIndex = i;
break;
}
start = end;
}
return CodeLineIndex(index + lineCount, chunkIndex);
}
List<CodeLine> toList() {
final List<CodeLine> codeLines = [];
for (final CodeLineSegment segment in segments) {
codeLines.addAll(segment.codeLines);
}
return codeLines;
}
@override
int get hashCode => segments.hashCode;
@override
bool operator ==(Object other) {
if (identical(this, other)) {
return true;
}
return other is CodeLines
&& listEquals(other.segments, segments);
}
@override
String toString() {
return '[ ${segments.join(',')} ]';
}
}
class CodeLineSegment with ListMixin<CodeLine> {
final List<CodeLine> codeLines;
final bool dirty;
const CodeLineSegment({
required this.codeLines,
this.dirty = false
});
factory CodeLineSegment.of({
required List<CodeLine> codeLines,
bool dirty = false
}) => _CodeLineSegmentQuckLineCount(
codeLines: codeLines,
dirty: dirty
);
@override
int get length => codeLines.length;
int get lineCount => codeLines.fold(0, (previousValue, element) => previousValue += element.lineCount);
@override
CodeLine operator [](int index) {
return codeLines[index];
}
@override
void operator []=(int index, CodeLine value) {
if (dirty) {
// Not support write operation
throw UnimplementedError();
} else {
codeLines[index] = value;
}
}
@override
set length(int newLength) {
if (dirty) {
// Not support write operation
throw UnimplementedError();
} else {
codeLines.length = newLength;
}
}
@override
void add(CodeLine element) {
if (dirty) {
// Not support write operation
throw UnimplementedError();
} else {
codeLines.add(element);
}
}
CodeLineSegment clone([int start = 0, int? end]) => CodeLineSegment.of(
codeLines: codeLines.sublist(start, end)
);
CodeLineSegment copyWith({
List<CodeLine>? codeLines,
bool? dirty,
}) {
return CodeLineSegment.of(
codeLines: codeLines ?? this.codeLines,
dirty: dirty ?? this.dirty
);
}
@override
int get hashCode => Object.hash(codeLines, lineCount, dirty);
@override
bool operator ==(Object other) {
if (identical(this, other)) {
return true;
}
return other is CodeLineSegment
&& listEquals(other.codeLines, codeLines)
&& other.lineCount == lineCount
&& other.dirty == dirty;
}
@override
String toString() {
return '[ ${join(',')} ]';
}
}