979 lines
24 KiB
Dart
979 lines
24 KiB
Dart
/// 增量保存模块
|
||
///
|
||
/// 实现操作日志（Command Pattern），支持：
|
||
/// - 快照 + 增量日志混合存储
|
||
/// - 撤销/重做功能
|
||
/// - 断点恢复
|
||
///
|
||
/// @version 0.1.0
|
||
/// @date 2026-03-07
|
||
|
||
import 'dart:convert';
|
||
import 'dart:typed_data';
|
||
|
||
// ============================================================================
|
||
// 操作类型枚举
|
||
// ============================================================================
|
||
|
||
/// 操作类型
|
||
enum OperationType {
|
||
componentAdd,
|
||
componentMove,
|
||
componentRotate,
|
||
componentDelete,
|
||
netAdd,
|
||
netConnect,
|
||
netDelete,
|
||
traceAdd,
|
||
traceDelete,
|
||
viaAdd,
|
||
propertyChange,
|
||
snapshot,
|
||
}
|
||
|
||
// ============================================================================
|
||
// 命令接口
|
||
// ============================================================================
|
||
|
||
/// 命令接口 (Command Pattern)
|
||
abstract class Command {
|
||
/// 执行命令
|
||
void execute();
|
||
|
||
/// 撤销命令
|
||
void undo();
|
||
|
||
/// 获取操作类型
|
||
OperationType get type;
|
||
|
||
/// 获取时间戳
|
||
DateTime get timestamp;
|
||
|
||
/// 序列化为 Map
|
||
Map<String, dynamic> toJson();
|
||
|
||
/// 从 Map 反序列化
|
||
factory Command.fromJson(Map<String, dynamic> json);
|
||
}
|
||
|
||
// ============================================================================
|
||
// 具体命令实现
|
||
// ============================================================================
|
||
|
||
/// 添加元件命令
|
||
class AddComponentCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.componentAdd;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final Map<String, dynamic> component;
|
||
final String? parentId;
|
||
|
||
// 撤销时需要的信息
|
||
String? _createdId;
|
||
|
||
AddComponentCommand({
|
||
required this.component,
|
||
this.parentId,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 实际执行由 Editor 处理
|
||
_createdId = component['id'];
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 删除创建的元件
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'componentAdd',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'component': component,
|
||
'parentId': parentId,
|
||
'createdId': _createdId,
|
||
};
|
||
}
|
||
|
||
factory Command.fromJson(Map<String, dynamic> json) {
|
||
switch (json['type']) {
|
||
case 'componentAdd':
|
||
return AddComponentCommand(
|
||
component: json['component'] as Map<String, dynamic>,
|
||
parentId: json['parentId'] as String?,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
case 'componentMove':
|
||
return MoveComponentCommand.fromJson(json);
|
||
case 'componentRotate':
|
||
return RotateComponentCommand.fromJson(json);
|
||
case 'componentDelete':
|
||
return DeleteComponentCommand.fromJson(json);
|
||
case 'netAdd':
|
||
return AddNetCommand.fromJson(json);
|
||
case 'propertyChange':
|
||
return PropertyChangeCommand.fromJson(json);
|
||
case 'snapshot':
|
||
return SnapshotCommand.fromJson(json);
|
||
default:
|
||
throw FormatException('Unknown command type: ${json['type']}');
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 移动元件命令
|
||
class MoveComponentCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.componentMove;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final String componentId;
|
||
final num oldX;
|
||
final num oldY;
|
||
final num newX;
|
||
final num newY;
|
||
|
||
MoveComponentCommand({
|
||
required this.componentId,
|
||
required this.oldX,
|
||
required this.oldY,
|
||
required this.newX,
|
||
required this.newY,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 移动到新位置 (已经在执行时应用)
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 移回旧位置
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'componentMove',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'componentId': componentId,
|
||
'oldX': oldX,
|
||
'oldY': oldY,
|
||
'newX': newX,
|
||
'newY': newY,
|
||
};
|
||
}
|
||
|
||
factory MoveComponentCommand.fromJson(Map<String, dynamic> json) {
|
||
return MoveComponentCommand(
|
||
componentId: json['componentId'] as String,
|
||
oldX: json['oldX'] as num,
|
||
oldY: json['oldY'] as num,
|
||
newX: json['newX'] as num,
|
||
newY: json['newY'] as num,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 旋转元件命令
|
||
class RotateComponentCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.componentRotate;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final String componentId;
|
||
final int oldRotation;
|
||
final int newRotation;
|
||
|
||
RotateComponentCommand({
|
||
required this.componentId,
|
||
required this.oldRotation,
|
||
required this.newRotation,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 旋转到新角度
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 旋转回旧角度
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'componentRotate',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'componentId': componentId,
|
||
'oldRotation': oldRotation,
|
||
'newRotation': newRotation,
|
||
};
|
||
}
|
||
|
||
factory RotateComponentCommand.fromJson(Map<String, dynamic> json) {
|
||
return RotateComponentCommand(
|
||
componentId: json['componentId'] as String,
|
||
oldRotation: json['oldRotation'] as int,
|
||
newRotation: json['newRotation'] as int,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 删除元件命令
|
||
class DeleteComponentCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.componentDelete;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final String componentId;
|
||
final Map<String, dynamic> component;
|
||
|
||
DeleteComponentCommand({
|
||
required this.componentId,
|
||
required this.component,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 删除元件
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 恢复元件
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'componentDelete',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'componentId': componentId,
|
||
'component': component,
|
||
};
|
||
}
|
||
|
||
factory DeleteComponentCommand.fromJson(Map<String, dynamic> json) {
|
||
return DeleteComponentCommand(
|
||
componentId: json['componentId'] as String,
|
||
component: json['component'] as Map<String, dynamic>,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 添加网络命令
|
||
class AddNetCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.netAdd;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final Map<String, dynamic> net;
|
||
|
||
AddNetCommand({
|
||
required this.net,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 添加网络
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 删除网络
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'netAdd',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'net': net,
|
||
};
|
||
}
|
||
|
||
factory AddNetCommand.fromJson(Map<String, dynamic> json) {
|
||
return AddNetCommand(
|
||
net: json['net'] as Map<String, dynamic>,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 属性变更命令
|
||
class PropertyChangeCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.propertyChange;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final String objectId;
|
||
final String propertyName;
|
||
final dynamic oldValue;
|
||
final dynamic newValue;
|
||
|
||
PropertyChangeCommand({
|
||
required this.objectId,
|
||
required this.propertyName,
|
||
required this.oldValue,
|
||
required this.newValue,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 应用新值
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 恢复旧值
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'propertyChange',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'objectId': objectId,
|
||
'propertyName': propertyName,
|
||
'oldValue': oldValue,
|
||
'newValue': newValue,
|
||
};
|
||
}
|
||
|
||
factory PropertyChangeCommand.fromJson(Map<String, dynamic> json) {
|
||
return PropertyChangeCommand(
|
||
objectId: json['objectId'] as String,
|
||
propertyName: json['propertyName'] as String,
|
||
oldValue: json['oldValue'],
|
||
newValue: json['newValue'],
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 快照命令
|
||
class SnapshotCommand implements Command {
|
||
@override
|
||
final OperationType type = OperationType.snapshot;
|
||
@override
|
||
final DateTime timestamp;
|
||
|
||
final Map<String, dynamic> fullState;
|
||
|
||
SnapshotCommand({
|
||
required this.fullState,
|
||
DateTime? timestamp,
|
||
}) : timestamp = timestamp ?? DateTime.now();
|
||
|
||
@override
|
||
void execute() {
|
||
// 保存完整状态
|
||
}
|
||
|
||
@override
|
||
void undo() {
|
||
// 快照不支持撤销
|
||
}
|
||
|
||
@override
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'type': 'snapshot',
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
'fullState': fullState,
|
||
};
|
||
}
|
||
|
||
factory SnapshotCommand.fromJson(Map<String, dynamic> json) {
|
||
return SnapshotCommand(
|
||
fullState: json['fullState'] as Map<String, dynamic>,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 操作历史记录
|
||
// ============================================================================
|
||
|
||
/// 操作历史记录管理器
|
||
class OperationHistory {
|
||
final List<Command> _undoStack = [];
|
||
final List<Command> _redoStack = [];
|
||
|
||
/// 最大历史记录数 (移动端建议：50-100)
|
||
final int maxStackSize;
|
||
|
||
/// 快照间隔 (每 N 次操作生成一个快照)
|
||
final int snapshotInterval;
|
||
|
||
/// 当前操作计数 (用于快照生成)
|
||
int _operationCount = 0;
|
||
|
||
OperationHistory({
|
||
this.maxStackSize = 50,
|
||
this.snapshotInterval = 100,
|
||
});
|
||
|
||
/// 添加操作到历史记录
|
||
void push(Command command) {
|
||
// 执行命令
|
||
command.execute();
|
||
|
||
// 添加到撤销栈
|
||
_undoStack.add(command);
|
||
_operationCount++;
|
||
|
||
// 清空重做栈 (新的操作使重做无效)
|
||
_redoStack.clear();
|
||
|
||
// 检查是否需要生成快照
|
||
if (_operationCount % snapshotInterval == 0) {
|
||
_generateSnapshot();
|
||
}
|
||
|
||
// 限制栈大小
|
||
if (_undoStack.length > maxStackSize) {
|
||
_undoStack.removeAt(0);
|
||
}
|
||
}
|
||
|
||
/// 撤销操作
|
||
Command? undo() {
|
||
if (_undoStack.isEmpty) {
|
||
return null;
|
||
}
|
||
|
||
final command = _undoStack.removeLast();
|
||
command.undo();
|
||
_redoStack.add(command);
|
||
|
||
return command;
|
||
}
|
||
|
||
/// 重做操作
|
||
Command? redo() {
|
||
if (_redoStack.isEmpty) {
|
||
return null;
|
||
}
|
||
|
||
final command = _redoStack.removeLast();
|
||
command.execute();
|
||
_undoStack.add(command);
|
||
|
||
return command;
|
||
}
|
||
|
||
/// 是否可以撤销
|
||
bool get canUndo => _undoStack.isNotEmpty;
|
||
|
||
/// 是否可以重做
|
||
bool get canRedo => _redoStack.isNotEmpty;
|
||
|
||
/// 获取撤销栈大小
|
||
int get undoStackSize => _undoStack.length;
|
||
|
||
/// 获取重做栈大小
|
||
int get redoStackSize => _redoStack.length;
|
||
|
||
/// 清除历史记录
|
||
void clear() {
|
||
_undoStack.clear();
|
||
_redoStack.clear();
|
||
_operationCount = 0;
|
||
}
|
||
|
||
/// 生成快照
|
||
void _generateSnapshot() {
|
||
// 快照由外部提供完整状态
|
||
// 这里只生成标记
|
||
}
|
||
|
||
/// 从快照恢复
|
||
void restoreFromSnapshot(Map<String, dynamic> snapshot) {
|
||
clear();
|
||
// 恢复状态由外部处理
|
||
}
|
||
|
||
/// 序列化为 JSON
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'undoStack': _undoStack.map((c) => c.toJson()).toList(),
|
||
'redoStack': _redoStack.map((c) => c.toJson()).toList(),
|
||
'operationCount': _operationCount,
|
||
};
|
||
}
|
||
|
||
/// 从 JSON 反序列化
|
||
factory OperationHistory.fromJson(Map<String, dynamic> json) {
|
||
final history = OperationHistory(
|
||
maxStackSize: json['maxStackSize'] as int? ?? 50,
|
||
snapshotInterval: json['snapshotInterval'] as int? ?? 100,
|
||
);
|
||
|
||
final undoList = json['undoStack'] as List? ?? [];
|
||
for (final cmdJson in undoList) {
|
||
history._undoStack.add(Command.fromJson(cmdJson as Map<String, dynamic>));
|
||
}
|
||
|
||
final redoList = json['redoStack'] as List? ?? [];
|
||
for (final cmdJson in redoList) {
|
||
history._redoStack.add(Command.fromJson(cmdJson as Map<String, dynamic>));
|
||
}
|
||
|
||
history._operationCount = json['operationCount'] as int? ?? 0;
|
||
|
||
return history;
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 增量保存管理器
|
||
// ============================================================================
|
||
|
||
/// 增量保存管理器
|
||
///
|
||
/// 管理快照和增量日志的混合存储
|
||
class IncrementalSaveManager {
|
||
/// 操作历史记录
|
||
final OperationHistory history;
|
||
|
||
/// 当前设计状态
|
||
Map<String, dynamic>? _currentState;
|
||
|
||
/// 最后一个快照
|
||
Map<String, dynamic>? _lastSnapshot;
|
||
|
||
/// 快照后的操作日志
|
||
final List<Command> _deltaLog = [];
|
||
|
||
/// 自动保存间隔 (毫秒)
|
||
final int autoSaveInterval;
|
||
|
||
/// 是否自动保存
|
||
bool _autoSaveEnabled = false;
|
||
|
||
IncrementalSaveManager({
|
||
OperationHistory? history,
|
||
this.autoSaveInterval = 30000, // 30 秒
|
||
}) : history = history ?? OperationHistory();
|
||
|
||
/// 设置当前状态
|
||
void setCurrentState(Map<String, dynamic> state) {
|
||
_currentState = state;
|
||
}
|
||
|
||
/// 记录操作
|
||
void recordOperation(Command command) {
|
||
history.push(command);
|
||
_deltaLog.add(command);
|
||
|
||
// 标记为脏数据
|
||
if (_currentState != null) {
|
||
_currentState!['metadata'] ??= {};
|
||
_currentState!['metadata']['isDirty'] = true;
|
||
}
|
||
}
|
||
|
||
/// 创建快照
|
||
void createSnapshot(Map<String, dynamic> fullState) {
|
||
_lastSnapshot = Map<String, dynamic>.from(fullState);
|
||
_deltaLog.clear();
|
||
|
||
// 记录快照命令
|
||
history.push(SnapshotCommand(fullState: fullState));
|
||
|
||
// 清除脏标记
|
||
fullState['metadata'] ??= {};
|
||
fullState['metadata']['isDirty'] = false;
|
||
fullState['metadata']['lastSavedAt'] = DateTime.now().millisecondsSinceEpoch;
|
||
}
|
||
|
||
/// 保存 (快照 + 增量)
|
||
IncrementalSaveData save() {
|
||
return IncrementalSaveData(
|
||
snapshot: _lastSnapshot,
|
||
deltaLog: _deltaLog.map((c) => c.toJson()).toList(),
|
||
timestamp: DateTime.now(),
|
||
);
|
||
}
|
||
|
||
/// 从保存数据恢复
|
||
Map<String, dynamic>? restore(IncrementalSaveData saveData) {
|
||
if (saveData.snapshot != null) {
|
||
_currentState = Map<String, dynamic>.from(saveData.snapshot!);
|
||
}
|
||
|
||
// 应用增量操作
|
||
for (final cmdJson in saveData.deltaLog) {
|
||
final command = Command.fromJson(cmdJson);
|
||
command.execute();
|
||
_applyCommandToState(command);
|
||
}
|
||
|
||
return _currentState;
|
||
}
|
||
|
||
/// 应用命令到状态
|
||
void _applyCommandToState(Command command) {
|
||
// 根据命令类型更新状态
|
||
switch (command.type) {
|
||
case OperationType.componentAdd:
|
||
_applyAddComponent(command as AddComponentCommand);
|
||
break;
|
||
case OperationType.componentMove:
|
||
_applyMoveComponent(command as MoveComponentCommand);
|
||
break;
|
||
case OperationType.componentRotate:
|
||
_applyRotateComponent(command as RotateComponentCommand);
|
||
break;
|
||
case OperationType.componentDelete:
|
||
_applyDeleteComponent(command as DeleteComponentCommand);
|
||
break;
|
||
case OperationType.netAdd:
|
||
_applyAddNet(command as AddNetCommand);
|
||
break;
|
||
case OperationType.propertyChange:
|
||
_applyPropertyChange(command as PropertyChangeCommand);
|
||
break;
|
||
case OperationType.snapshot:
|
||
_applySnapshot(command as SnapshotCommand);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
void _applyAddComponent(AddComponentCommand command) {
|
||
if (_currentState == null) return;
|
||
|
||
final tables = _currentState!['tables'] as Map<String, dynamic>?;
|
||
if (tables == null) return;
|
||
|
||
final components = tables['components'] as List?;
|
||
if (components != null) {
|
||
components.add(command.component);
|
||
}
|
||
}
|
||
|
||
void _applyMoveComponent(MoveComponentCommand command) {
|
||
if (_currentState == null) return;
|
||
|
||
final tables = _currentState!['tables'] as Map<String, dynamic>?;
|
||
if (tables == null) return;
|
||
|
||
final components = tables['components'] as List?;
|
||
if (components != null) {
|
||
for (final comp in components) {
|
||
if (comp is Map && comp['id'] == command.componentId) {
|
||
comp['position'] ??= {};
|
||
comp['position']['x'] = command.newX;
|
||
comp['position']['y'] = command.newY;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void _applyRotateComponent(RotateComponentCommand command) {
|
||
if (_currentState == null) return;
|
||
|
||
final tables = _currentState!['tables'] as Map<String, dynamic>?;
|
||
if (tables == null) return;
|
||
|
||
final components = tables['components'] as List?;
|
||
if (components != null) {
|
||
for (final comp in components) {
|
||
if (comp is Map && comp['id'] == command.componentId) {
|
||
comp['position'] ??= {};
|
||
comp['position']['rotation'] = command.newRotation;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void _applyDeleteComponent(DeleteComponentCommand command) {
|
||
if (_currentState == null) return;
|
||
|
||
final tables = _currentState!['tables'] as Map<String, dynamic>?;
|
||
if (tables == null) return;
|
||
|
||
final components = tables['components'] as List?;
|
||
if (components != null) {
|
||
components.removeWhere((comp) =>
|
||
comp is Map && comp['id'] == command.componentId
|
||
);
|
||
}
|
||
}
|
||
|
||
void _applyAddNet(AddNetCommand command) {
|
||
if (_currentState == null) return;
|
||
|
||
final tables = _currentState!['tables'] as Map<String, dynamic>?;
|
||
if (tables == null) return;
|
||
|
||
final nets = tables['nets'] as List?;
|
||
if (nets != null) {
|
||
nets.add(command.net);
|
||
}
|
||
}
|
||
|
||
void _applyPropertyChange(PropertyChangeCommand command) {
|
||
if (_currentState == null) return;
|
||
|
||
// 查找对象并更新属性
|
||
final tables = _currentState!['tables'] as Map<String, dynamic>?;
|
||
if (tables == null) return;
|
||
|
||
for (final table in tables.values) {
|
||
if (table is List) {
|
||
for (final obj in table) {
|
||
if (obj is Map && obj['id'] == command.objectId) {
|
||
obj[command.propertyName] = command.newValue;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void _applySnapshot(SnapshotCommand command) {
|
||
_currentState = Map<String, dynamic>.from(command.fullState);
|
||
_lastSnapshot = Map<String, dynamic>.from(command.fullState);
|
||
}
|
||
|
||
/// 启用自动保存
|
||
void enableAutoSave() {
|
||
_autoSaveEnabled = true;
|
||
}
|
||
|
||
/// 禁用自动保存
|
||
void disableAutoSave() {
|
||
_autoSaveEnabled = false;
|
||
}
|
||
|
||
/// 获取当前状态
|
||
Map<String, dynamic>? get currentState => _currentState;
|
||
|
||
/// 获取最后快照
|
||
Map<String, dynamic>? get lastSnapshot => _lastSnapshot;
|
||
|
||
/// 是否有未保存的更改
|
||
bool get isDirty => _deltaLog.isNotEmpty;
|
||
|
||
/// 获取增量日志大小
|
||
int get deltaLogSize => _deltaLog.length;
|
||
}
|
||
|
||
// ============================================================================
|
||
// 保存数据
|
||
// ============================================================================
|
||
|
||
/// 增量保存数据
|
||
class IncrementalSaveData {
|
||
/// 完整快照 (可能为 null，如果是纯增量保存)
|
||
final Map<String, dynamic>? snapshot;
|
||
|
||
/// 增量操作日志
|
||
final List<Map<String, dynamic>> deltaLog;
|
||
|
||
/// 保存时间戳
|
||
final DateTime timestamp;
|
||
|
||
IncrementalSaveData({
|
||
this.snapshot,
|
||
this.deltaLog = const [],
|
||
required this.timestamp,
|
||
});
|
||
|
||
/// 序列化为 JSON 字符串
|
||
String toJsonString() {
|
||
return jsonEncode({
|
||
'snapshot': snapshot,
|
||
'deltaLog': deltaLog,
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
});
|
||
}
|
||
|
||
/// 从 JSON 字符串反序列化
|
||
factory IncrementalSaveData.fromJsonString(String jsonString) {
|
||
final json = jsonDecode(jsonString) as Map<String, dynamic>;
|
||
return IncrementalSaveData(
|
||
snapshot: json['snapshot'] as Map<String, dynamic>?,
|
||
deltaLog: (json['deltaLog'] as List? ?? [])
|
||
.map((e) => e as Map<String, dynamic>)
|
||
.toList(),
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
|
||
/// 序列化为字节 (用于文件存储)
|
||
Uint8List toBytes() {
|
||
final jsonString = toJsonString();
|
||
return Uint8List.fromList(utf8.encode(jsonString));
|
||
}
|
||
|
||
/// 从字节反序列化
|
||
factory IncrementalSaveData.fromBytes(Uint8List bytes) {
|
||
final jsonString = utf8.decode(bytes);
|
||
return IncrementalSaveData.fromJsonString(jsonString);
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 断点恢复
|
||
// ============================================================================
|
||
|
||
/// 断点恢复管理器
|
||
class CheckpointManager {
|
||
/// 检查点列表
|
||
final List<Checkpoint> _checkpoints = [];
|
||
|
||
/// 最大检查点数
|
||
final int maxCheckpoints;
|
||
|
||
CheckpointManager({this.maxCheckpoints = 10});
|
||
|
||
/// 创建检查点
|
||
void createCheckpoint(
|
||
String name,
|
||
Map<String, dynamic> state,
|
||
String reason,
|
||
) {
|
||
final checkpoint = Checkpoint(
|
||
name: name,
|
||
state: Map<String, dynamic>.from(state),
|
||
reason: reason,
|
||
timestamp: DateTime.now(),
|
||
);
|
||
|
||
_checkpoints.add(checkpoint);
|
||
|
||
// 限制检查点数量
|
||
if (_checkpoints.length > maxCheckpoints) {
|
||
_checkpoints.removeAt(0);
|
||
}
|
||
}
|
||
|
||
/// 获取最新检查点
|
||
Checkpoint? getLatestCheckpoint() {
|
||
if (_checkpoints.isEmpty) {
|
||
return null;
|
||
}
|
||
return _checkpoints.last;
|
||
}
|
||
|
||
/// 获取指定名称的检查点
|
||
Checkpoint? getCheckpoint(String name) {
|
||
for (final checkpoint in _checkpoints) {
|
||
if (checkpoint.name == name) {
|
||
return checkpoint;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/// 从检查点恢复
|
||
Map<String, dynamic>? restoreFromCheckpoint(String name) {
|
||
final checkpoint = getCheckpoint(name);
|
||
return checkpoint?.state;
|
||
}
|
||
|
||
/// 从最新检查点恢复
|
||
Map<String, dynamic>? restoreFromLatest() {
|
||
final checkpoint = getLatestCheckpoint();
|
||
return checkpoint?.state;
|
||
}
|
||
|
||
/// 清除所有检查点
|
||
void clear() {
|
||
_checkpoints.clear();
|
||
}
|
||
|
||
/// 获取检查点列表
|
||
List<Checkpoint> get checkpoints => List.unmodifiable(_checkpoints);
|
||
}
|
||
|
||
/// 检查点
|
||
class Checkpoint {
|
||
final String name;
|
||
final Map<String, dynamic> state;
|
||
final String reason;
|
||
final DateTime timestamp;
|
||
|
||
Checkpoint({
|
||
required this.name,
|
||
required this.state,
|
||
required this.reason,
|
||
required this.timestamp,
|
||
});
|
||
|
||
/// 序列化为 JSON
|
||
Map<String, dynamic> toJson() {
|
||
return {
|
||
'name': name,
|
||
'state': state,
|
||
'reason': reason,
|
||
'timestamp': timestamp.millisecondsSinceEpoch,
|
||
};
|
||
}
|
||
|
||
/// 从 JSON 反序列化
|
||
factory Checkpoint.fromJson(Map<String, dynamic> json) {
|
||
return Checkpoint(
|
||
name: json['name'] as String,
|
||
state: json['state'] as Map<String, dynamic>,
|
||
reason: json['reason'] as String,
|
||
timestamp: DateTime.fromMillisecondsSinceEpoch(json['timestamp'] as int),
|
||
);
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 公共 API
|
||
// ============================================================================
|
||
|
||
/// 创建增量保存管理器
|
||
IncrementalSaveManager createIncrementalSaveManager({
|
||
int maxHistorySize = 50,
|
||
int snapshotInterval = 100,
|
||
int autoSaveInterval = 30000,
|
||
}) {
|
||
final history = OperationHistory(
|
||
maxStackSize: maxHistorySize,
|
||
snapshotInterval: snapshotInterval,
|
||
);
|
||
|
||
return IncrementalSaveManager(
|
||
history: history,
|
||
autoSaveInterval: autoSaveInterval,
|
||
);
|
||
}
|
||
|
||
/// 创建断点恢复管理器
|
||
CheckpointManager createCheckpointManager({int maxCheckpoints = 10}) {
|
||
return CheckpointManager(maxCheckpoints: maxCheckpoints);
|
||
}
|