Class for simulation result. Tracks were added to the result and no

longer as a listener. #2

Author: caduandrade

example/example.dart

@@ -1,11 +1,16 @@
 import 'package:simdart/simdart.dart';
+import 'package:simdart/src/sim_result.dart';
 
 void main() async {
-  final SimDart sim = SimDart(onTrack: (track) => print(track));
+  final SimDart sim = SimDart(includeTracks: true);
 
   sim.process(event: _a, name: 'A');
 
-  await sim.run(until: 10);
+  SimResult result = await sim.run(until: 10);
+
+  result.tracks?.forEach((track) => print(track));
+  print('startTime: ${result.startTime}');
+  print('duration: ${result.duration}');
 }
 
 void _a(EventContext context) async {

lib/src/internal/event_action.dart

@@ -16,7 +16,6 @@ class EventAction extends TimeAction implements EventContext {
       required String? eventName,
       required this.event,
       required this.resourceId,
-      required this.onTrack,
       required this.onReject,
       required this.secondarySortByName})
       : _sim = sim,
@@ -26,10 +25,6 @@ class EventAction extends TimeAction implements EventContext {
   final String? _eventName;
   String get eventName => _eventName ?? hashCode.toString();
 
-  /// A callback function used to track the progress of the simulation.
-  /// If provided, this function will be called with each [SimulationTrack] generated
-  /// during the simulation. This is useful for debugging or logging purposes.
-  final OnTrack? onTrack;
 
   /// The event to be executed.
   final Event event;
@@ -62,10 +57,12 @@ class EventAction extends TimeAction implements EventContext {
   void execute() {
     final Function()? resume = _resume;
 
+    
+
     if (resume != null) {
-      if (onTrack != null) {
-        onTrack!(SimDartHelper.buildSimulationTrack(
-            sim: _sim, eventName: eventName, status: Status.resumed));
+      if (_sim.includeTracks) {
+        SimDartHelper.addSimulationTrack(
+            sim: _sim, eventName: eventName, status: Status.resumed);
       }
       // Resume the event if it is waiting, otherwise execute its action.
       resume.call();
@@ -78,13 +75,13 @@ class EventAction extends TimeAction implements EventContext {
       _resourceAcquired = resource.acquire(this);
     }
 
-    if (onTrack != null) {
+    if (_sim.includeTracks) {
       Status status = Status.executed;
       if (!_canRun) {
         status = Status.rejected;
       }
-      onTrack!(SimDartHelper.buildSimulationTrack(
-          sim: _sim, eventName: eventName, status: status));
+      SimDartHelper.addSimulationTrack(
+          sim: _sim, eventName: eventName, status: status);
     }
 
     if (_canRun) {

lib/src/internal/sim_configuration_interface.dart

@@ -0,0 +1,30 @@
+import 'package:meta/meta.dart';
+import 'package:simdart/src/execution_priority.dart';
+import 'package:simdart/src/start_time_handling.dart';
+
+
+@internal
+abstract interface class SimConfigurationInterface {
+  /// Specifies how the simulation handles start times in the past.
+  StartTimeHandling get startTimeHandling;
+
+  /// Defines the priority of task execution in the simulation.
+  ///
+  /// - `highPriority`: Uses `Future.microtask` for immediate execution, prioritizing
+  ///   processing without blocking the UI.
+  /// - `lowPriority`: Uses `Future.delayed(Duration.zero)` to ensure non-blocking
+  ///   execution, allowing the UI to remain responsive.
+  ExecutionPriority get executionPriority;
+
+  /// Determines whether simulation tracks should be included in the simulation result.
+  ///
+  /// When set to `true`, the simulation will collect and return a list of [SimulationTrack]
+  /// objects as part of its result. If set to `false`, the tracks will not be collected,
+  /// and the list will be `null`.
+  ///
+  /// Default: `false`
+  bool get includeTracks;
+
+
+
+}

lib/src/internal/time_loop_interface.dart renamed to lib/src/internal/sim_result_interface.dart

@@ -1,21 +1,8 @@
 import 'package:meta/meta.dart';
-import 'package:simdart/src/execution_priority.dart';
-import 'package:simdart/src/internal/now_interface.dart';
-import 'package:simdart/src/start_time_handling.dart';
 
-/// Represents the temporal loop in the algorithm, managing the execution of actions at specified times.
+/// Represents the simulation result.
 @internal
-abstract interface class TimeLoopInterface implements NowInterface {
-  /// Specifies how the simulation handles start times in the past.
-  StartTimeHandling get startTimeHandling;
-
-  /// Defines the priority of task execution in the simulation.
-  ///
-  /// - `highPriority`: Uses `Future.microtask` for immediate execution, prioritizing
-  ///   processing without blocking the UI.
-  /// - `lowPriority`: Uses `Future.delayed(Duration.zero)` to ensure non-blocking
-  ///   execution, allowing the UI to remain responsive.
-  ExecutionPriority get executionPriority;
+abstract interface class SimResultInterface {
 
   /// The time, in simulated time units, when the simulation started.
   /// This is the moment at which the first event is scheduled to be processed.

lib/src/internal/time_loop.dart

@@ -3,16 +3,21 @@ import 'dart:async';
 import 'package:collection/collection.dart';
 import 'package:meta/meta.dart';
 import 'package:simdart/src/execution_priority.dart';
+import 'package:simdart/src/internal/now_interface.dart';
+import 'package:simdart/src/internal/sim_result_interface.dart';
 import 'package:simdart/src/internal/time_action.dart';
-import 'package:simdart/src/internal/time_loop_interface.dart';
+import 'package:simdart/src/internal/sim_configuration_interface.dart';
+import 'package:simdart/src/sim_result.dart';
+import 'package:simdart/src/simulation_track.dart';
 import 'package:simdart/src/start_time_handling.dart';
 
 /// Represents the temporal loop in the algorithm, managing the execution of actions at specified times.
 @internal
-class TimeLoop implements TimeLoopInterface {
+class TimeLoop implements SimConfigurationInterface,NowInterface,SimResultInterface  {
   TimeLoop(
       {required int? now,
       required this.beforeRun,
+        required this.includeTracks,
       required this.executionPriority,
       required this.startTimeHandling}) {
     _now = now ?? 0;
@@ -29,6 +34,9 @@ class TimeLoop implements TimeLoopInterface {
 
   final Function beforeRun;
 
+  @override
+  final bool  includeTracks;
+
   /// Queue that holds the [TimeAction] instances to be executed at their respective times.
   final PriorityQueue<TimeAction> _actions = PriorityQueue<TimeAction>(
     (a, b) {
@@ -58,22 +66,24 @@ class TimeLoop implements TimeLoopInterface {
   int get now => _now;
   late int _now;
 
+  List<SimulationTrack>? _tracks;
+
   Completer<void>? _terminator;
 
   /// Runs the simulation, processing actions in chronological order.
-  Future<void> run({int? until}) async {
+  Future<SimResult> run({int? until}) async {
     if (until != null && _now > until) {
       throw ArgumentError('`now` must be less than or equal to `until`.');
     }
     _until = until;
 
     if (_terminator != null) {
-      return;
+      return _buildResult();
     }
     if (_actions.isEmpty) {
       _duration = 0;
       _startTime = 0;
-      return;
+      return _buildResult();
     }
     _duration = null;
     _startTime = null;
@@ -85,6 +95,11 @@ class TimeLoop implements TimeLoopInterface {
     await _terminator?.future;
     _duration = _now - (startTime ?? 0);
     _terminator = null;
+    return _buildResult();
+  }
+
+  SimResult _buildResult(){
+    return SimResult(startTime: startTime, duration: duration, tracks: _tracks);
   }
 
   void _scheduleNextEvent() {
@@ -105,6 +120,11 @@ class TimeLoop implements TimeLoopInterface {
     _actions.add(action);
   }
 
+  void addTrack(SimulationTrack track){
+    _tracks ??= [];
+    _tracks!.add(track);
+  }
+
   Future<void> _consumeFirstEvent() async {
     _nextEventScheduled = false;
     if (_actions.isEmpty) {

lib/src/sim_result.dart

@@ -0,0 +1,20 @@
+import 'dart:collection';
+
+import 'package:simdart/src/internal/sim_result_interface.dart';
+import 'package:simdart/src/simulation_track.dart';
+
+class SimResult implements SimResultInterface {
+  SimResult(
+      {required this.duration,
+      required this.startTime,
+      required List<SimulationTrack>? tracks})
+      : tracks = tracks != null ? UnmodifiableListView(tracks) : null;
+
+  @override
+  final int? duration;
+
+  @override
+  final int? startTime;
+
+  final UnmodifiableListView<SimulationTrack>? tracks;
+}

lib/src/simdart.dart

@@ -7,18 +7,20 @@ import 'package:simdart/src/event.dart';
 import 'package:simdart/src/execution_priority.dart';
 import 'package:simdart/src/internal/event_action.dart';
 import 'package:simdart/src/internal/event_scheduler_interface.dart';
+import 'package:simdart/src/internal/now_interface.dart';
 import 'package:simdart/src/internal/repeat_event_action.dart';
 import 'package:simdart/src/internal/resource.dart';
 import 'package:simdart/src/internal/time_action.dart';
 import 'package:simdart/src/internal/time_loop.dart';
-import 'package:simdart/src/internal/time_loop_interface.dart';
+import 'package:simdart/src/internal/sim_configuration_interface.dart';
 import 'package:simdart/src/interval.dart';
 import 'package:simdart/src/resource_configurator.dart';
+import 'package:simdart/src/sim_result.dart';
 import 'package:simdart/src/simulation_track.dart';
 import 'package:simdart/src/start_time_handling.dart';
 
 /// Represents a discrete-event simulation engine.
-class SimDart implements TimeLoopInterface, EventSchedulerInterface {
+class SimDart implements SimConfigurationInterface, EventSchedulerInterface,NowInterface  {
   /// Creates a simulation instance.
   ///
   /// - [now]: The starting time of the simulation. Defaults to `0` if null.
@@ -27,8 +29,7 @@ class SimDart implements TimeLoopInterface, EventSchedulerInterface {
   /// - [startTimeHandling]: Determines how to handle events scheduled with a start
   /// time in the past. The default behavior is [StartTimeHandling.throwErrorIfPast].
   ///
-  /// - [onTrack]: The optional callback function that can be used to track the progress
-  /// of the simulation.
+  /// - [includeTracks]: Determines whether simulation tracks should be included in the simulation result.
   ///
   /// - [seed]: The optional parameter used to initialize the random number generator
   /// for deterministic behavior in the simulation. If provided, it ensures that the
@@ -40,22 +41,25 @@ class SimDart implements TimeLoopInterface, EventSchedulerInterface {
   /// - [executionPriority]: Defines the priority of task execution in the simulation.
   SimDart(
       {StartTimeHandling startTimeHandling = StartTimeHandling.throwErrorIfPast,
-      OnTrack? onTrack,
       int? now,
       this.secondarySortByName = false,
+        this.includeTracks=false,
       ExecutionPriority executionPriority = ExecutionPriority.high,
       int? seed})
-      : _onTrack = onTrack,
-        random = Random(seed) {
+      :   random = Random(seed) {
     _loop = TimeLoop(
         now: now,
+        includeTracks: includeTracks,
         beforeRun: _beforeRun,
         executionPriority: executionPriority,
         startTimeHandling: startTimeHandling);
   }
 
   late final TimeLoop _loop;
 
+  @override
+  final bool includeTracks;
+
   /// Determines whether events with the same start time are sorted by their event name.
   ///
   /// The primary sorting criterion is always the simulated start time (`start`). If
@@ -77,11 +81,6 @@ class SimDart implements TimeLoopInterface, EventSchedulerInterface {
   /// instantiate a new `Random` object for each event.
   late final Random random;
 
-  /// A callback function used to track the progress of the simulation.
-  /// If provided, this function will be called with each [SimulationTrack] generated
-  /// during the simulation. This is useful for debugging or logging purposes.
-  final OnTrack? _onTrack;
-
   /// A queue that holds event actions that are waiting for a resource to become available.
   ///
   /// These events were initially denied the resource and are placed in this queue
@@ -101,7 +100,7 @@ class SimDart implements TimeLoopInterface, EventSchedulerInterface {
   ///
   /// - [until]: The time at which execution should stop. Execution will include events
   ///   scheduled at this time (inclusive). If null, execution will continue indefinitely.
-  Future<void> run({int? until}) async {
+  Future<SimResult> run({int? until}) async {
     return _loop.run(until: until);
   }
 
@@ -190,7 +189,6 @@ class SimDart implements TimeLoopInterface, EventSchedulerInterface {
     } else {
       _loop.addAction(EventAction(
           sim: this,
-          onTrack: _onTrack,
           start: start,
           eventName: name,
           event: event,
@@ -200,25 +198,17 @@ class SimDart implements TimeLoopInterface, EventSchedulerInterface {
     }
   }
 
-  @override
-  int? get duration => _loop.duration;
-
   @override
   ExecutionPriority get executionPriority => _loop.executionPriority;
 
   @override
   int get now => _loop.now;
 
-  @override
-  int? get startTime => _loop.startTime;
 
   @override
   StartTimeHandling get startTimeHandling => _loop.startTimeHandling;
 }
 
-/// A function signature for tracking the progress of a simulation.
-typedef OnTrack = void Function(SimulationTrack track);
-
 /// Defines the behavior of the interval after a newly created event has been rejected.
 enum RejectedEventPolicy {
   /// Continues the repetition of the event at the specified intervals, even after the event was rejected.
@@ -275,18 +265,18 @@ class SimDartHelper {
     return sim._resources[resourceId];
   }
 
-  static SimulationTrack buildSimulationTrack(
+  static void addSimulationTrack(
       {required SimDart sim,
       required String eventName,
       required Status status}) {
     Map<String, int> resourceUsage = {};
     for (Resource resource in sim._resources.values) {
       resourceUsage[resource.id] = resource.queue.length;
     }
-    return SimulationTrack(
+    sim._loop.addTrack(SimulationTrack(
         status: status,
         name: eventName,
         time: sim.now,
-        resourceUsage: resourceUsage);
+        resourceUsage: resourceUsage));
   }
 }