new: cpu line chart

lib/data/model/app/range.dart

@@ -0,0 +1,11 @@
+final class Range<T extends num> {
+  final T start;
+  final T end;
+
+  Range(this.start, this.end);
+
+  bool contains(int value) => value >= start && value <= end;
+
+  @override
+  String toString() => 'Range($start, $end)';
+}

lib/data/model/server/cpu.dart

@@ -1,9 +1,13 @@
 import 'dart:collection';
 
+import 'package:fl_chart/fl_chart.dart';
+import 'package:toolbox/data/model/app/range.dart';
 import 'package:toolbox/data/model/server/time_seq.dart';
 import 'package:toolbox/data/res/status.dart';
 
-class Cpus extends TimeSeq<List<OneTimeCpuStatus>> {
+const _kCap = 30;
+
+class Cpus extends TimeSeq<List<SingleCoreCpu>> {
   Cpus(super.init1, super.init2);
 
   @override
@@ -14,6 +18,8 @@ class Cpus extends TimeSeq<List<OneTimeCpuStatus>> {
     _sys = _getSys();
     _iowait = _getIowait();
     _idle = _getIdle();
+    _updateSpots();
+    _updateRange();
   }
 
   double usedPercent({int coreIdx = 0}) {
@@ -60,9 +66,53 @@ class Cpus extends TimeSeq<List<OneTimeCpuStatus>> {
   double _idle = 0;
   double get idle => _idle;
   double _getIdle() => 100 - usedPercent();
+
+  /// [core1, core2]
+  /// core1: [FlSpot(0, 10), FlSpot(1, 20), FlSpot(2, 30)]
+  final _spots = <Fifo<FlSpot>>[];
+  List<Fifo<FlSpot>> get spots => _spots;
+  void _updateSpots() {
+    for (var i = 1; i < now.length; i++) {
+      if (i >= _spots.length) {
+        _spots.add(Fifo(capacity: _kCap));
+      } else {
+        final item = _spots[i];
+        final spot = FlSpot(item.count.toDouble(), usedPercent(coreIdx: i));
+        item.add(spot);
+      }
+    }
+  }
+
+  var _rangeX = Range<double>(0.0, _kCap.toDouble());
+  Range<double> get rangeX => _rangeX;
+  // var _rangeY = Range<double>(0.0, 100.0);
+  // Range<double> get rangeY => _rangeY;
+  void _updateRange() {
+    double? minX, maxX;
+    for (var i = 1; i < now.length; i++) {
+      final item = _spots[i];
+      if (item.isEmpty) continue;
+      final first = item.first.x;
+      final last = item.last.x;
+      if (minX == null || first < minX) minX = first;
+      if (maxX == null || last > maxX) maxX = last;
+    }
+    if (minX != null && maxX != null) _rangeX = Range(minX, maxX);
+
+    // double? minY, maxY;
+    // for (var i = 1; i < now.length; i++) {
+    //   final item = _spots[i];
+    //   if (item.isEmpty) continue;
+    //   final first = item.first.y;
+    //   final last = item.last.y;
+    //   if (minY == null || first < minY) minY = first;
+    //   if (maxY == null || last > maxY) maxY = last;
+    // }
+    // if (minY != null && maxY != null) _rangeY = Range(minY, maxY);
+  }
 }
 
-class OneTimeCpuStatus extends TimeSeqIface<OneTimeCpuStatus> {
+class SingleCoreCpu extends TimeSeqIface<SingleCoreCpu> {
   final String id;
   final int user;
   final int sys;
@@ -72,7 +122,7 @@ class OneTimeCpuStatus extends TimeSeqIface<OneTimeCpuStatus> {
   final int irq;
   final int softirq;
 
-  OneTimeCpuStatus(
+  SingleCoreCpu(
     this.id,
     this.user,
     this.sys,
@@ -86,10 +136,10 @@ class OneTimeCpuStatus extends TimeSeqIface<OneTimeCpuStatus> {
   int get total => user + sys + nice + idle + iowait + irq + softirq;
 
   @override
-  bool same(OneTimeCpuStatus other) => id == other.id;
+  bool same(SingleCoreCpu other) => id == other.id;
 
-  static List<OneTimeCpuStatus> parse(String raw) {
-    final List<OneTimeCpuStatus> cpus = [];
+  static List<SingleCoreCpu> parse(String raw) {
+    final List<SingleCoreCpu> cpus = [];
 
     for (var item in raw.split('\n')) {
       if (item == '') break;
@@ -97,7 +147,7 @@ class OneTimeCpuStatus extends TimeSeqIface<OneTimeCpuStatus> {
       if (id == null) continue;
       final matches = item.replaceFirst(id, '').trim().split(' ');
       cpus.add(
-        OneTimeCpuStatus(
+        SingleCoreCpu(
           id,
           int.parse(matches[0]),
           int.parse(matches[1]),
@@ -128,7 +178,7 @@ Cpus parseBsdCpu(String raw) {
 
   final init = InitStatus.cpus;
   init.add([
-    OneTimeCpuStatus('cpu', percents[0].toInt(), 0, 0,
+    SingleCoreCpu('cpu', percents[0].toInt(), 0, 0,
         percents[2].toInt() + percents[1].toInt(), 0, 0, 0),
   ]);
   return init;

lib/data/model/server/server_status_update_req.dart

@@ -69,7 +69,7 @@ Future<ServerStatus> _getLinuxStatus(ServerStatusUpdateReq req) async {
   }
 
   try {
-    final cpus = OneTimeCpuStatus.parse(StatusCmdType.cpu.find(segments));
+    final cpus = SingleCoreCpu.parse(StatusCmdType.cpu.find(segments));
     req.ss.cpu.update(cpus);
   } catch (e, s) {
     Loggers.parse.warning(e, s);

lib/data/model/server/time_seq.dart

@@ -1,21 +1,16 @@
 import 'dart:collection';
 
-/// A FIFO queue with fixed capacity.
-abstract class TimeSeq<T extends List<TimeSeqIface>> extends ListBase<T> {
+class Fifo<T> extends ListBase<T> {
   final int capacity;
   late final List<T> _list;
+  var _count = 0;
 
-  /// Due to the design, at least two elements are required, otherwise [pre] /
-  /// [now] will throw.
-  TimeSeq(
-    T init1,
-    T init2, {
-    this.capacity = 30,
-  }) : _list = [init1, init2];
+  Fifo({this.capacity = 30, List<T>? list}) : _list = list ?? <T>[];
 
   @override
   void add(element) {
-    if (length == capacity) {
+    _count++;
+    if (_list.length == capacity) {
       _list.removeAt(0);
     }
     _list.add(element);
@@ -24,6 +19,8 @@ abstract class TimeSeq<T extends List<TimeSeqIface>> extends ListBase<T> {
   @override
   int get length => _list.length;
 
+  int get count => _count;
+
   @override
   set length(int newLength) {
     throw UnimplementedError();
@@ -38,6 +35,16 @@ abstract class TimeSeq<T extends List<TimeSeqIface>> extends ListBase<T> {
   void operator []=(int index, value) {
     _list[index] = value;
   }
+}
+
+abstract class TimeSeq<T extends List<TimeSeqIface>> extends Fifo<T> {
+  /// Due to the design, at least two elements are required, otherwise [pre] /
+  /// [now] will throw.
+  TimeSeq(
+    T init1,
+    T init2, {
+    super.capacity,
+  }) : super(list: [init1, init2]);
 
   T get pre {
     return _list[length - 2];