Flutter字典序排序插件lexicographical_order的使用

lexicographical_order 是一个用于生成字典序字符串的Flutter插件，旨在通过更高效的重新排序、排序和交错事务来增强有序序列的实时编辑。

关于

该插件设计用于生成字典序字符串，以优化数据的排序和管理。它特别适用于需要频繁调整顺序的应用场景，如任务列表或项目管理工具。

使用方法

1. between(String prev, String next)

此方法生成一个位于prev和next之间的字典序字符串。返回的字符串可以作为某些数据的排序键。

import 'package:lexicographical_order/lexicographical_order.dart';

void main() {
  final mid = between(prev: 'B', next: 'D');
  assert(
    areEqual(
      [mid, 'D', 'B']..sort(),
      ['B', mid, 'D'],
    ),
  );
  print('Generated string: $mid');
}

2. generateOrderKeys(int keyCount)

此方法生成一系列字符串作为排序键。

import 'package:lexicographical_order/lexicographical_order.dart';

void main() {
  final keyCount = 100;
  final orderKeys = generateOrderKeys(keyCount);
  print('Generated keys count: ${orderKeys.length}');
}

使用场景示例

空表或集合时：

Future<void> addTodo(CreateTodo command) async {
  final String orderKey = todos.isEmpty 
    ? generateOrderKeys(1).first // 当表为空时生成第一个键
    : between(prev: todos.last.orderKey);
       
  final todo = await todoRepository.create(command, orderKey);
  todos.add(todo);
}

迁移至高效有序系统时：

Future<void> migrateToLexicalOrderSystem(Table table) async {
  final itemCount = table.count();
  final orderKeys = generateOrderKeys(itemCount);
  // 省略具体实现细节
}

完整示例Demo

以下是一个完整的示例，展示了如何在实际应用中使用lexicographical_order插件：

// ignore_for_file: public_member_api_docs, sort_constructors_first
import 'package:equatable/equatable.dart';
import 'package:fast_immutable_collections/fast_immutable_collections.dart';
import 'package:lexicographical_order/lexicographical_order.dart';
import 'package:to_string_pretty/to_string_pretty.dart';

main() async {
  final todoService = TodoService();

  await todoService.add(title: 'Create a backend.');
  await todoService.add(title: 'Write an article.');
  await todoService.add(title: 'Intensive Workout.');
  print(toStringPretty(todoService.todos));

  await todoService.completeTodoAndMoveDown(todoService.todos.first);
  print(toStringPretty(todoService.todos));

  await todoService.reorderBetween(
    target: todoService.todos.first,
    prev: todoService.todos.elementAt(1),
    next: todoService.todos.elementAt(2),
  );
  print(toStringPretty(todoService.todos));
}

class TodoService {
  static int _nextId = 1;

  /// The set is sorted by `Todo.orderKey`.
  var _memoryDB = ISet.withConfig(
    <Todo>{},
    ConfigSet(sort: true),
  );

  UnmodifiableSetFromISet get todos => UnmodifiableSetFromISet(_memoryDB);

  Future<Todo> add({
    required String title,
  }) async {
    final id = _nextId;
    _nextId++;
    final orderKey = _memoryDB.isEmpty
        ? generateOrderKeys(1).first
        : between(prev: _memoryDB.last.orderKey);

    final entity =
        Todo(id: id, title: title, orderKey: orderKey, isCompleted: false);

    _memoryDB = _memoryDB.add(entity);
    return entity;
  }

  Future<Todo> reorderBetween({
    required Todo target,
    Todo? prev,
    Todo? next,
  }) async {
    if (prev == null && next == null) {
      throw ArgumentError("the target can't be reordered");
    }
    final newOrderKey = between(
      prev: prev?.orderKey,
      next: next?.orderKey,
    );
    final copied = target.copyWith(orderKey: newOrderKey);
    _memoryDB = _memoryDB.remove(target).add(copied);

    return copied;
  }

  Future<Todo> completeTodoAndMoveDown(Todo target) async {
    final orderKey = _memoryDB.isEmpty
        ? generateOrderKeys(1).first
        : between(prev: _memoryDB.last.orderKey);

    final copied = target.copyWith(orderKey: orderKey, isCompleted: true);
    _memoryDB = _memoryDB.remove(target).add(copied);
    return copied;
  }
}

class Todo with EquatableMixin, Comparable<Todo> {
  final int id;
  final String title;
  final bool isCompleted;
  final String orderKey;

  Todo({
    required this.id,
    required this.title,
    required this.isCompleted,
    required this.orderKey,
  });

  @override
  List<Object> get props => [id];

  @override
  int compareTo(Todo other) => orderKey.compareTo(other.orderKey);

  Todo copyWith({
    int? id,
    String? title,
    bool? isCompleted,
    String? orderKey,
  }) {
    return Todo(
      id: id ?? this.id,
      title: title ?? this.title,
      isCompleted: isCompleted ?? this.isCompleted,
      orderKey: orderKey ?? this.orderKey,
    );
  }

  @override
  String toString() {
    final checkbox = isCompleted ? '✅' : '▢';
    return '$checkbox $title';
  }
}

以上代码展示了一个简单的待办事项服务，利用lexicographical_order插件来管理任务的顺序和完成状态。通过这个插件，我们可以轻松地对任务进行排序和重新排列。