Xin Yao
4 years ago
parent
78e4800538
commit
9211afc479
15 changed files with 700 additions and 20 deletions
@ -0,0 +1,688 @@ |
||||
// Copyright (c) 2018, Anatoly Pulyaevskiy. All rights reserved. Use of this source code |
||||
// is governed by a BSD-style license that can be found in the LICENSE file. |
||||
|
||||
/// Implementation of Quill Delta format in Dart. |
||||
library quill_delta; |
||||
|
||||
import 'dart:math' as math; |
||||
|
||||
import 'package:collection/collection.dart'; |
||||
import 'package:quiver_hashcode/hashcode.dart'; |
||||
|
||||
const _attributeEquality = DeepCollectionEquality(); |
||||
const _valueEquality = DeepCollectionEquality(); |
||||
|
||||
/// Decoder function to convert raw `data` object into a user-defined data type. |
||||
/// |
||||
/// Useful with embedded content. |
||||
typedef DataDecoder = Object Function(Object data); |
||||
|
||||
/// Default data decoder which simply passes through the original value. |
||||
Object _passThroughDataDecoder(Object data) => data; |
||||
|
||||
/// Operation performed on a rich-text document. |
||||
class Operation { |
||||
/// Key of insert operations. |
||||
static const String insertKey = 'insert'; |
||||
|
||||
/// Key of delete operations. |
||||
static const String deleteKey = 'delete'; |
||||
|
||||
/// Key of retain operations. |
||||
static const String retainKey = 'retain'; |
||||
|
||||
/// Key of attributes collection. |
||||
static const String attributesKey = 'attributes'; |
||||
|
||||
static const List<String> _validKeys = [insertKey, deleteKey, retainKey]; |
||||
|
||||
/// Key of this operation, can be "insert", "delete" or "retain". |
||||
final String key; |
||||
|
||||
/// Length of this operation. |
||||
final int length; |
||||
|
||||
/// Payload of "insert" operation, for other types is set to empty string. |
||||
final Object data; |
||||
|
||||
/// Rich-text attributes set by this operation, can be `null`. |
||||
Map<String, dynamic> get attributes => |
||||
_attributes == null ? null : Map<String, dynamic>.from(_attributes); |
||||
final Map<String, dynamic> _attributes; |
||||
|
||||
Operation._(this.key, this.length, this.data, Map attributes) |
||||
: assert(key != null && length != null && data != null), |
||||
assert(_validKeys.contains(key), 'Invalid operation key "$key".'), |
||||
assert(() { |
||||
if (key != Operation.insertKey) return true; |
||||
return data is String ? data.length == length : length == 1; |
||||
}(), 'Length of insert operation must be equal to the data length.'), |
||||
_attributes = |
||||
attributes != null ? Map<String, dynamic>.from(attributes) : null; |
||||
|
||||
/// Creates new [Operation] from JSON payload. |
||||
/// |
||||
/// If `dataDecoder` parameter is not null then it is used to additionally |
||||
/// decode the operation's data object. Only applied to insert operations. |
||||
static Operation fromJson(Map data, {DataDecoder dataDecoder}) { |
||||
dataDecoder ??= _passThroughDataDecoder; |
||||
final map = Map<String, dynamic>.from(data); |
||||
if (map.containsKey(Operation.insertKey)) { |
||||
final data = dataDecoder(map[Operation.insertKey]); |
||||
final dataLength = data is String ? data.length : 1; |
||||
return Operation._( |
||||
Operation.insertKey, dataLength, data, map[Operation.attributesKey]); |
||||
} else if (map.containsKey(Operation.deleteKey)) { |
||||
final int length = map[Operation.deleteKey]; |
||||
return Operation._(Operation.deleteKey, length, '', null); |
||||
} else if (map.containsKey(Operation.retainKey)) { |
||||
final int length = map[Operation.retainKey]; |
||||
return Operation._( |
||||
Operation.retainKey, length, '', map[Operation.attributesKey]); |
||||
} |
||||
throw ArgumentError.value(data, 'Invalid data for Delta operation.'); |
||||
} |
||||
|
||||
/// Returns JSON-serializable representation of this operation. |
||||
Map<String, dynamic> toJson() { |
||||
final json = {key: value}; |
||||
if (_attributes != null) json[Operation.attributesKey] = attributes; |
||||
return json; |
||||
} |
||||
|
||||
/// Creates operation which deletes [length] of characters. |
||||
factory Operation.delete(int length) => |
||||
Operation._(Operation.deleteKey, length, '', null); |
||||
|
||||
/// Creates operation which inserts [text] with optional [attributes]. |
||||
factory Operation.insert(dynamic data, [Map<String, dynamic> attributes]) => |
||||
Operation._(Operation.insertKey, data is String ? data.length : 1, data, |
||||
attributes); |
||||
|
||||
/// Creates operation which retains [length] of characters and optionally |
||||
/// applies attributes. |
||||
factory Operation.retain(int length, [Map<String, dynamic> attributes]) => |
||||
Operation._(Operation.retainKey, length, '', attributes); |
||||
|
||||
/// Returns value of this operation. |
||||
/// |
||||
/// For insert operations this returns text, for delete and retain - length. |
||||
dynamic get value => (key == Operation.insertKey) ? data : length; |
||||
|
||||
/// Returns `true` if this is a delete operation. |
||||
bool get isDelete => key == Operation.deleteKey; |
||||
|
||||
/// Returns `true` if this is an insert operation. |
||||
bool get isInsert => key == Operation.insertKey; |
||||
|
||||
/// Returns `true` if this is a retain operation. |
||||
bool get isRetain => key == Operation.retainKey; |
||||
|
||||
/// Returns `true` if this operation has no attributes, e.g. is plain text. |
||||
bool get isPlain => (_attributes == null || _attributes.isEmpty); |
||||
|
||||
/// Returns `true` if this operation sets at least one attribute. |
||||
bool get isNotPlain => !isPlain; |
||||
|
||||
/// Returns `true` is this operation is empty. |
||||
/// |
||||
/// An operation is considered empty if its [length] is equal to `0`. |
||||
bool get isEmpty => length == 0; |
||||
|
||||
/// Returns `true` is this operation is not empty. |
||||
bool get isNotEmpty => length > 0; |
||||
|
||||
@override |
||||
bool operator ==(other) { |
||||
if (identical(this, other)) return true; |
||||
if (other is! Operation) return false; |
||||
Operation typedOther = other; |
||||
return key == typedOther.key && |
||||
length == typedOther.length && |
||||
_valueEquality.equals(data, typedOther.data) && |
||||
hasSameAttributes(typedOther); |
||||
} |
||||
|
||||
/// Returns `true` if this operation has attribute specified by [name]. |
||||
bool hasAttribute(String name) => isNotPlain && _attributes.containsKey(name); |
||||
|
||||
/// Returns `true` if [other] operation has the same attributes as this one. |
||||
bool hasSameAttributes(Operation other) { |
||||
return _attributeEquality.equals(_attributes, other._attributes); |
||||
} |
||||
|
||||
@override |
||||
int get hashCode { |
||||
if (_attributes != null && _attributes.isNotEmpty) { |
||||
final attrsHash = |
||||
hashObjects(_attributes.entries.map((e) => hash2(e.key, e.value))); |
||||
return hash3(key, value, attrsHash); |
||||
} |
||||
return hash2(key, value); |
||||
} |
||||
|
||||
@override |
||||
String toString() { |
||||
final attr = attributes == null ? '' : ' + $attributes'; |
||||
final text = isInsert |
||||
? (data is String |
||||
? (data as String).replaceAll('\n', '⏎') |
||||
: data.toString()) |
||||
: '$length'; |
||||
return '$key⟨ $text ⟩$attr'; |
||||
} |
||||
} |
||||
|
||||
/// Delta represents a document or a modification of a document as a sequence of |
||||
/// insert, delete and retain operations. |
||||
/// |
||||
/// Delta consisting of only "insert" operations is usually referred to as |
||||
/// "document delta". When delta includes also "retain" or "delete" operations |
||||
/// it is a "change delta". |
||||
class Delta { |
||||
/// Transforms two attribute sets. |
||||
static Map<String, dynamic> transformAttributes( |
||||
Map<String, dynamic> a, Map<String, dynamic> b, bool priority) { |
||||
if (a == null) return b; |
||||
if (b == null) return null; |
||||
|
||||
if (!priority) return b; |
||||
|
||||
final result = b.keys.fold<Map<String, dynamic>>({}, (attributes, key) { |
||||
if (!a.containsKey(key)) attributes[key] = b[key]; |
||||
return attributes; |
||||
}); |
||||
|
||||
return result.isEmpty ? null : result; |
||||
} |
||||
|
||||
/// Composes two attribute sets. |
||||
static Map<String, dynamic> composeAttributes( |
||||
Map<String, dynamic> a, Map<String, dynamic> b, |
||||
{bool keepNull = false}) { |
||||
a ??= const {}; |
||||
b ??= const {}; |
||||
|
||||
final result = Map<String, dynamic>.from(a)..addAll(b); |
||||
final keys = result.keys.toList(growable: false); |
||||
|
||||
if (!keepNull) { |
||||
for (final key in keys) { |
||||
if (result[key] == null) result.remove(key); |
||||
} |
||||
} |
||||
|
||||
return result.isEmpty ? null : result; |
||||
} |
||||
|
||||
///get anti-attr result base on base |
||||
static Map<String, dynamic> invertAttributes( |
||||
Map<String, dynamic> attr, Map<String, dynamic> base) { |
||||
attr ??= const {}; |
||||
base ??= const {}; |
||||
|
||||
var baseInverted = base.keys.fold({}, (memo, key) { |
||||
if (base[key] != attr[key] && attr.containsKey(key)) { |
||||
memo[key] = base[key]; |
||||
} |
||||
return memo; |
||||
}); |
||||
|
||||
var inverted = |
||||
Map<String, dynamic>.from(attr.keys.fold(baseInverted, (memo, key) { |
||||
if (base[key] != attr[key] && !base.containsKey(key)) { |
||||
memo[key] = null; |
||||
} |
||||
return memo; |
||||
})); |
||||
return inverted; |
||||
} |
||||
|
||||
final List<Operation> _operations; |
||||
|
||||
int _modificationCount = 0; |
||||
|
||||
Delta._(List<Operation> operations) |
||||
: assert(operations != null), |
||||
_operations = operations; |
||||
|
||||
/// Creates new empty [Delta]. |
||||
factory Delta() => Delta._(<Operation>[]); |
||||
|
||||
/// Creates new [Delta] from [other]. |
||||
factory Delta.from(Delta other) => |
||||
Delta._(List<Operation>.from(other._operations)); |
||||
|
||||
/// Creates [Delta] from de-serialized JSON representation. |
||||
/// |
||||
/// If `dataDecoder` parameter is not null then it is used to additionally |
||||
/// decode the operation's data object. Only applied to insert operations. |
||||
static Delta fromJson(List data, {DataDecoder dataDecoder}) { |
||||
return Delta._(data |
||||
.map((op) => Operation.fromJson(op, dataDecoder: dataDecoder)) |
||||
.toList()); |
||||
} |
||||
|
||||
/// Returns list of operations in this delta. |
||||
List<Operation> toList() => List.from(_operations); |
||||
|
||||
/// Returns JSON-serializable version of this delta. |
||||
List toJson() => toList(); |
||||
|
||||
/// Returns `true` if this delta is empty. |
||||
bool get isEmpty => _operations.isEmpty; |
||||
|
||||
/// Returns `true` if this delta is not empty. |
||||
bool get isNotEmpty => _operations.isNotEmpty; |
||||
|
||||
/// Returns number of operations in this delta. |
||||
int get length => _operations.length; |
||||
|
||||
/// Returns [Operation] at specified [index] in this delta. |
||||
Operation operator [](int index) => _operations[index]; |
||||
|
||||
/// Returns [Operation] at specified [index] in this delta. |
||||
Operation elementAt(int index) => _operations.elementAt(index); |
||||
|
||||
/// Returns the first [Operation] in this delta. |
||||
Operation get first => _operations.first; |
||||
|
||||
/// Returns the last [Operation] in this delta. |
||||
Operation get last => _operations.last; |
||||
|
||||
@override |
||||
bool operator ==(dynamic other) { |
||||
if (identical(this, other)) return true; |
||||
if (other is! Delta) return false; |
||||
Delta typedOther = other; |
||||
final comparator = |
||||
ListEquality<Operation>(const DefaultEquality<Operation>()); |
||||
return comparator.equals(_operations, typedOther._operations); |
||||
} |
||||
|
||||
@override |
||||
int get hashCode => hashObjects(_operations); |
||||
|
||||
/// Retain [count] of characters from current position. |
||||
void retain(int count, [Map<String, dynamic> attributes]) { |
||||
assert(count >= 0); |
||||
if (count == 0) return; // no-op |
||||
push(Operation.retain(count, attributes)); |
||||
} |
||||
|
||||
/// Insert [data] at current position. |
||||
void insert(dynamic data, [Map<String, dynamic> attributes]) { |
||||
assert(data != null); |
||||
if (data is String && data.isEmpty) return; // no-op |
||||
push(Operation.insert(data, attributes)); |
||||
} |
||||
|
||||
/// Delete [count] characters from current position. |
||||
void delete(int count) { |
||||
assert(count >= 0); |
||||
if (count == 0) return; |
||||
push(Operation.delete(count)); |
||||
} |
||||
|
||||
void _mergeWithTail(Operation operation) { |
||||
assert(isNotEmpty); |
||||
assert(operation != null && last.key == operation.key); |
||||
assert(operation.data is String && last.data is String); |
||||
|
||||
final length = operation.length + last.length; |
||||
final lastText = last.data as String; |
||||
final opText = operation.data as String; |
||||
final resultText = lastText + opText; |
||||
final index = _operations.length; |
||||
_operations.replaceRange(index - 1, index, [ |
||||
Operation._(operation.key, length, resultText, operation.attributes), |
||||
]); |
||||
} |
||||
|
||||
/// Pushes new operation into this delta. |
||||
/// |
||||
/// Performs compaction by composing [operation] with current tail operation |
||||
/// of this delta, when possible. For instance, if current tail is |
||||
/// `insert('abc')` and pushed operation is `insert('123')` then existing |
||||
/// tail is replaced with `insert('abc123')` - a compound result of the two |
||||
/// operations. |
||||
void push(Operation operation) { |
||||
if (operation.isEmpty) return; |
||||
|
||||
var index = _operations.length; |
||||
final lastOp = _operations.isNotEmpty ? _operations.last : null; |
||||
if (lastOp != null) { |
||||
if (lastOp.isDelete && operation.isDelete) { |
||||
_mergeWithTail(operation); |
||||
return; |
||||
} |
||||
|
||||
if (lastOp.isDelete && operation.isInsert) { |
||||
index -= 1; // Always insert before deleting |
||||
final nLastOp = (index > 0) ? _operations.elementAt(index - 1) : null; |
||||
if (nLastOp == null) { |
||||
_operations.insert(0, operation); |
||||
return; |
||||
} |
||||
} |
||||
|
||||
if (lastOp.isInsert && operation.isInsert) { |
||||
if (lastOp.hasSameAttributes(operation) && |
||||
operation.data is String && |
||||
lastOp.data is String) { |
||||
_mergeWithTail(operation); |
||||
return; |
||||
} |
||||
} |
||||
|
||||
if (lastOp.isRetain && operation.isRetain) { |
||||
if (lastOp.hasSameAttributes(operation)) { |
||||
_mergeWithTail(operation); |
||||
return; |
||||
} |
||||
} |
||||
} |
||||
if (index == _operations.length) { |
||||
_operations.add(operation); |
||||
} else { |
||||
final opAtIndex = _operations.elementAt(index); |
||||
_operations.replaceRange(index, index + 1, [operation, opAtIndex]); |
||||
} |
||||
_modificationCount++; |
||||
} |
||||
|
||||
/// Composes next operation from [thisIter] and [otherIter]. |
||||
/// |
||||
/// Returns new operation or `null` if operations from [thisIter] and |
||||
/// [otherIter] nullify each other. For instance, for the pair `insert('abc')` |
||||
/// and `delete(3)` composition result would be empty string. |
||||
Operation _composeOperation(DeltaIterator thisIter, DeltaIterator otherIter) { |
||||
if (otherIter.isNextInsert) return otherIter.next(); |
||||
if (thisIter.isNextDelete) return thisIter.next(); |
||||
|
||||
final length = math.min(thisIter.peekLength(), otherIter.peekLength()); |
||||
final thisOp = thisIter.next(length); |
||||
final otherOp = otherIter.next(length); |
||||
assert(thisOp.length == otherOp.length); |
||||
|
||||
if (otherOp.isRetain) { |
||||
final attributes = composeAttributes( |
||||
thisOp.attributes, |
||||
otherOp.attributes, |
||||
keepNull: thisOp.isRetain, |
||||
); |
||||
if (thisOp.isRetain) { |
||||
return Operation.retain(thisOp.length, attributes); |
||||
} else if (thisOp.isInsert) { |
||||
return Operation.insert(thisOp.data, attributes); |
||||
} else { |
||||
throw StateError('Unreachable'); |
||||
} |
||||
} else { |
||||
// otherOp == delete && thisOp in [retain, insert] |
||||
assert(otherOp.isDelete); |
||||
if (thisOp.isRetain) return otherOp; |
||||
assert(thisOp.isInsert); |
||||
// otherOp(delete) + thisOp(insert) => null |
||||
} |
||||
return null; |
||||
} |
||||
|
||||
/// Composes this delta with [other] and returns new [Delta]. |
||||
/// |
||||
/// It is not required for this and [other] delta to represent a document |
||||
/// delta (consisting only of insert operations). |
||||
Delta compose(Delta other) { |
||||
final result = Delta(); |
||||
final thisIter = DeltaIterator(this); |
||||
final otherIter = DeltaIterator(other); |
||||
|
||||
while (thisIter.hasNext || otherIter.hasNext) { |
||||
final newOp = _composeOperation(thisIter, otherIter); |
||||
if (newOp != null) result.push(newOp); |
||||
} |
||||
return result..trim(); |
||||
} |
||||
|
||||
/// Transforms next operation from [otherIter] against next operation in |
||||
/// [thisIter]. |
||||
/// |
||||
/// Returns `null` if both operations nullify each other. |
||||
Operation _transformOperation( |
||||
DeltaIterator thisIter, DeltaIterator otherIter, bool priority) { |
||||
if (thisIter.isNextInsert && (priority || !otherIter.isNextInsert)) { |
||||
return Operation.retain(thisIter.next().length); |
||||
} else if (otherIter.isNextInsert) { |
||||
return otherIter.next(); |
||||
} |
||||
|
||||
final length = math.min(thisIter.peekLength(), otherIter.peekLength()); |
||||
final thisOp = thisIter.next(length); |
||||
final otherOp = otherIter.next(length); |
||||
assert(thisOp.length == otherOp.length); |
||||
|
||||
// At this point only delete and retain operations are possible. |
||||
if (thisOp.isDelete) { |
||||
// otherOp is either delete or retain, so they nullify each other. |
||||
return null; |
||||
} else if (otherOp.isDelete) { |
||||
return otherOp; |
||||
} else { |
||||
// Retain otherOp which is either retain or insert. |
||||
return Operation.retain( |
||||
length, |
||||
transformAttributes(thisOp.attributes, otherOp.attributes, priority), |
||||
); |
||||
} |
||||
} |
||||
|
||||
/// Transforms [other] delta against operations in this delta. |
||||
Delta transform(Delta other, bool priority) { |
||||
final result = Delta(); |
||||
final thisIter = DeltaIterator(this); |
||||
final otherIter = DeltaIterator(other); |
||||
|
||||
while (thisIter.hasNext || otherIter.hasNext) { |
||||
final newOp = _transformOperation(thisIter, otherIter, priority); |
||||
if (newOp != null) result.push(newOp); |
||||
} |
||||
return result..trim(); |
||||
} |
||||
|
||||
/// Removes trailing retain operation with empty attributes, if present. |
||||
void trim() { |
||||
if (isNotEmpty) { |
||||
final last = _operations.last; |
||||
if (last.isRetain && last.isPlain) _operations.removeLast(); |
||||
} |
||||
} |
||||
|
||||
/// Concatenates [other] with this delta and returns the result. |
||||
Delta concat(Delta other) { |
||||
final result = Delta.from(this); |
||||
if (other.isNotEmpty) { |
||||
// In case first operation of other can be merged with last operation in |
||||
// our list. |
||||
result.push(other._operations.first); |
||||
result._operations.addAll(other._operations.sublist(1)); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/// Inverts this delta against [base]. |
||||
/// |
||||
/// Returns new delta which negates effect of this delta when applied to |
||||
/// [base]. This is an equivalent of "undo" operation on deltas. |
||||
Delta invert(Delta base) { |
||||
final inverted = Delta(); |
||||
if (base.isEmpty) return inverted; |
||||
|
||||
var baseIndex = 0; |
||||
for (final op in _operations) { |
||||
if (op.isInsert) { |
||||
inverted.delete(op.length); |
||||
} else if (op.isRetain && op.isPlain) { |
||||
inverted.retain(op.length, null); |
||||
baseIndex += op.length; |
||||
} else if (op.isDelete || (op.isRetain && op.isNotPlain)) { |
||||
final length = op.length; |
||||
final sliceDelta = base.slice(baseIndex, baseIndex + length); |
||||
sliceDelta.toList().forEach((baseOp) { |
||||
if (op.isDelete) { |
||||
inverted.push(baseOp); |
||||
} else if (op.isRetain && op.isNotPlain) { |
||||
var invertAttr = invertAttributes(op.attributes, baseOp.attributes); |
||||
inverted.retain( |
||||
baseOp.length, invertAttr.isEmpty ? null : invertAttr); |
||||
} |
||||
}); |
||||
baseIndex += length; |
||||
} else { |
||||
throw StateError('Unreachable'); |
||||
} |
||||
} |
||||
inverted.trim(); |
||||
return inverted; |
||||
} |
||||
|
||||
/// Returns slice of this delta from [start] index (inclusive) to [end] |
||||
/// (exclusive). |
||||
Delta slice(int start, [int end]) { |
||||
final delta = Delta(); |
||||
var index = 0; |
||||
var opIterator = DeltaIterator(this); |
||||
|
||||
final actualEnd = end ?? double.infinity; |
||||
|
||||
while (index < actualEnd && opIterator.hasNext) { |
||||
Operation op; |
||||
if (index < start) { |
||||
op = opIterator.next(start - index); |
||||
} else { |
||||
op = opIterator.next(actualEnd - index); |
||||
delta.push(op); |
||||
} |
||||
index += op.length; |
||||
} |
||||
return delta; |
||||
} |
||||
|
||||
/// Transforms [index] against this delta. |
||||
/// |
||||
/// Any "delete" operation before specified [index] shifts it backward, as |
||||
/// well as any "insert" operation shifts it forward. |
||||
/// |
||||
/// The [force] argument is used to resolve scenarios when there is an |
||||
/// insert operation at the same position as [index]. If [force] is set to |
||||
/// `true` (default) then position is forced to shift forward, otherwise |
||||
/// position stays at the same index. In other words setting [force] to |
||||
/// `false` gives higher priority to the transformed position. |
||||
/// |
||||
/// Useful to adjust caret or selection positions. |
||||
int transformPosition(int index, {bool force = true}) { |
||||
final iter = DeltaIterator(this); |
||||
var offset = 0; |
||||
while (iter.hasNext && offset <= index) { |
||||
final op = iter.next(); |
||||
if (op.isDelete) { |
||||
index -= math.min(op.length, index - offset); |
||||
continue; |
||||
} else if (op.isInsert && (offset < index || force)) { |
||||
index += op.length; |
||||
} |
||||
offset += op.length; |
||||
} |
||||
return index; |
||||
} |
||||
|
||||
@override |
||||
String toString() => _operations.join('\n'); |
||||
} |
||||
|
||||
/// Specialized iterator for [Delta]s. |
||||
class DeltaIterator { |
||||
final Delta delta; |
||||
final int _modificationCount; |
||||
int _index = 0; |
||||
num _offset = 0; |
||||
|
||||
DeltaIterator(this.delta) : _modificationCount = delta._modificationCount; |
||||
|
||||
bool get isNextInsert => nextOperationKey == Operation.insertKey; |
||||
|
||||
bool get isNextDelete => nextOperationKey == Operation.deleteKey; |
||||
|
||||
bool get isNextRetain => nextOperationKey == Operation.retainKey; |
||||
|
||||
String get nextOperationKey { |
||||
if (_index < delta.length) { |
||||
return delta.elementAt(_index).key; |
||||
} else { |
||||
return null; |
||||
} |
||||
} |
||||
|
||||
bool get hasNext => peekLength() < double.infinity; |
||||
|
||||
/// Returns length of next operation without consuming it. |
||||
/// |
||||
/// Returns [double.infinity] if there is no more operations left to iterate. |
||||
num peekLength() { |
||||
if (_index < delta.length) { |
||||
final operation = delta._operations[_index]; |
||||
return operation.length - _offset; |
||||
} |
||||
return double.infinity; |
||||
} |
||||
|
||||
/// Consumes and returns next operation. |
||||
/// |
||||
/// Optional [length] specifies maximum length of operation to return. Note |
||||
/// that actual length of returned operation may be less than specified value. |
||||
Operation next([num length = double.infinity]) { |
||||
assert(length != null); |
||||
|
||||
if (_modificationCount != delta._modificationCount) { |
||||
throw ConcurrentModificationError(delta); |
||||
} |
||||
|
||||
if (_index < delta.length) { |
||||
final op = delta.elementAt(_index); |
||||
final opKey = op.key; |
||||
final opAttributes = op.attributes; |
||||
final _currentOffset = _offset; |
||||
final actualLength = math.min(op.length - _currentOffset, length); |
||||
if (actualLength == op.length - _currentOffset) { |
||||
_index++; |
||||
_offset = 0; |
||||
} else { |
||||
_offset += actualLength; |
||||
} |
||||
final opData = op.isInsert && op.data is String |
||||
? (op.data as String) |
||||
.substring(_currentOffset, _currentOffset + actualLength) |
||||
: op.data; |
||||
final opIsNotEmpty = |
||||
opData is String ? opData.isNotEmpty : true; // embeds are never empty |
||||
final opLength = opData is String ? opData.length : 1; |
||||
final int opActualLength = opIsNotEmpty ? opLength : actualLength; |
||||
return Operation._(opKey, opActualLength, opData, opAttributes); |
||||
} |
||||
return Operation.retain(length); |
||||
} |
||||
|
||||
/// Skips [length] characters in source delta. |
||||
/// |
||||
/// Returns last skipped operation, or `null` if there was nothing to skip. |
||||
Operation skip(int length) { |
||||
var skipped = 0; |
||||
Operation op; |
||||
while (skipped < length && hasNext) { |
||||
final opLength = peekLength(); |
||||
final skip = math.min(length - skipped, opLength); |
||||
op = next(skip); |
||||
skipped += op.length; |
||||
} |
||||
return op; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue