Changeset 16779 for trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Store.cs

Timestamp:

04/12/19 13:45:11 (5 years ago)

Author:

abeham

Message:

#2975: Updated Sim# to 3.1.1

Location:

trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1

Files:

• . (moved) (moved from trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11)
• SimSharp-3.1.1 (copied) (copied from trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11)
• SimSharp-3.1.1/Core/Resources/Store.cs (modified) (7 diffs)

trunk/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.1.1/SimSharp-3.1.1/Core/Resources/Store.cs

@@ -1 +1 @@
 #region License Information
 /* SimSharp - A .NET port of SimPy, discrete event simulation framework
-Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+Copyright (C) 2019  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 
 This program is free software: you can redistribute it and/or modify
@@ -19 +19 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace SimSharp {
+  /// <summary>
+  /// The store holds a variable number of individual items.
+  /// The items are removed from the store in FIFO order.
+  /// 
+  /// Put are processed in FIFO order.
+  /// Get are processed in FIFO order.
+  /// </summary>
   public class Store {
+
+    public int Capacity { get; protected set; }
+
     public int Count { get { return Items.Count; } }
-    public int Capacity { get; protected set; }
-    protected Environment Environment { get; private set; }
+
+    protected Simulation Environment { get; private set; }
 
     protected Queue<StorePut> PutQueue { get; private set; }
     protected Queue<StoreGet> GetQueue { get; private set; }
-    protected List<object> Items { get; private set; }
-
-    public Store(Environment environment, int capacity = int.MaxValue) {
+    protected Queue<object> Items { get; private set; }
+    protected List<Event> WhenNewQueue { get; private set; }
+    protected List<Event> WhenAnyQueue { get; private set; }
+    protected List<Event> WhenFullQueue { get; private set; }
+    protected List<Event> WhenEmptyQueue { get; private set; }
+    protected List<Event> WhenChangeQueue { get; private set; }
+
+    public Store(Simulation environment, int capacity = int.MaxValue) {
       if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
       Environment = environment;
@@ -37 +51 @@
       PutQueue = new Queue<StorePut>();
       GetQueue = new Queue<StoreGet>();
-      Items = new List<object>();
+      Items = new Queue<object>();
+      WhenNewQueue = new List<Event>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+    }
+    public Store(Simulation environment, IEnumerable<object> items, int capacity = int.MaxValue) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      PutQueue = new Queue<StorePut>();
+      GetQueue = new Queue<StoreGet>();
+      Items = new Queue<object>(items);
+      WhenNewQueue = new List<Event>();
+      WhenAnyQueue = new List<Event>();
+      WhenFullQueue = new List<Event>();
+      WhenEmptyQueue = new List<Event>();
+      WhenChangeQueue = new List<Event>();
+      if (capacity < Items.Count) throw new ArgumentException("There are more initial items than there is capacity.", "items");
     }
 
@@ -54 +87 @@
     }
 
+    public virtual Event WhenNew() {
+      var whenNew = new Event(Environment);
+      WhenNewQueue.Add(whenNew);
+      return whenNew;
+    }
+
+    public virtual Event WhenAny() {
+      var whenAny = new Event(Environment);
+      WhenAnyQueue.Add(whenAny);
+      TriggerWhenAny();
+      return whenAny;
+    }
+
+    public virtual Event WhenFull() {
+      var whenFull = new Event(Environment);
+      WhenFullQueue.Add(whenFull);
+      TriggerWhenFull();
+      return whenFull;
+    }
+
+    public virtual Event WhenEmpty() {
+      var whenEmpty = new Event(Environment);
+      WhenEmptyQueue.Add(whenEmpty);
+      TriggerWhenEmpty();
+      return whenEmpty;
+    }
+
+    public virtual Event WhenChange() {
+      var whenChange = new Event(Environment);
+      WhenChangeQueue.Add(whenChange);
+      return whenChange;
+    }
+
     protected virtual void DoPut(StorePut put) {
       if (Items.Count < Capacity) {
-        Items.Add(put.Value);
+        Items.Enqueue(put.Value);
         put.Succeed();
       }
@@ -63 +129 @@
     protected virtual void DoGet(StoreGet get) {
       if (Items.Count > 0) {
-        var item = Items.First();
-        Items.RemoveAt(0);
+        var item = Items.Dequeue();
         get.Succeed(item);
       }
@@ -75 +140 @@
         if (put.IsTriggered) {
           PutQueue.Dequeue();
+          TriggerWhenNew();
+          TriggerWhenAny();
+          TriggerWhenFull();
+          TriggerWhenChange();
         } else break;
       }
@@ -85 +154 @@
         if (get.IsTriggered) {
           GetQueue.Dequeue();
+          TriggerWhenEmpty();
+          TriggerWhenChange();
         } else break;
       }
+    }
+
+    protected virtual void TriggerWhenNew() {
+      if (WhenNewQueue.Count == 0) return;
+      foreach (var evt in WhenNewQueue)
+        evt.Succeed();
+      WhenNewQueue.Clear();
+    }
+
+    protected virtual void TriggerWhenAny() {
+      if (Count > 0) {
+        if (WhenAnyQueue.Count == 0) return;
+        foreach (var evt in WhenAnyQueue)
+          evt.Succeed();
+        WhenAnyQueue.Clear();
+      }
+    }
+
+    protected virtual void TriggerWhenFull() {
+      if (Count == Capacity) {
+        if (WhenFullQueue.Count == 0) return;
+        foreach (var evt in WhenFullQueue)
+          evt.Succeed();
+        WhenFullQueue.Clear();
+      }
+    }
+
+    protected virtual void TriggerWhenEmpty() {
+      if (Count == 0) {
+        if (WhenEmptyQueue.Count == 0) return;
+        foreach (var evt in WhenEmptyQueue)
+          evt.Succeed();
+        WhenEmptyQueue.Clear();
+      }
+    }
+
+    protected virtual void TriggerWhenChange() {
+      if (WhenChangeQueue.Count == 0) return;
+      foreach (var evt in WhenChangeQueue)
+        evt.Succeed();
+      WhenChangeQueue.Clear();
     }
   }