Two-valued fault tree analyzer WIP

1 files changed, 188 insertions, 0 deletions

diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java
new file mode 100644
index 00000000..dceef9f8
--- /dev/null
+++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java
@@ -0,0 +1,188 @@
+package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft;
+
+import com.google.common.collect.ImmutableSet;
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ConstantEvent;
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Event;
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.RandomEvent;
+import java.util.Set;
+import org.eclipse.xtend.lib.annotations.Data;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.Pure;
+import org.eclipse.xtext.xbase.lib.util.ToStringBuilder;
+
+@Data
+@SuppressWarnings("all")
+public class EventCollection {
+  public static class Builder {
+    private int falseEventCount = 0;
+    
+    private int trueEventCount = 0;
+    
+    private final ImmutableSet.Builder<RandomEvent> randomEventsBuilder = ImmutableSet.<RandomEvent>builder();
+    
+    private Builder() {
+    }
+    
+    public EventCollection.Builder add(final Event event) {
+      EventCollection.Builder _xblockexpression = null;
+      {
+        boolean _matched = false;
+        if (event instanceof ConstantEvent) {
+          _matched=true;
+          boolean _isFailed = ((ConstantEvent)event).isFailed();
+          if (_isFailed) {
+            this.trueEventCount++;
+          } else {
+            this.falseEventCount++;
+          }
+        }
+        if (!_matched) {
+          if (event instanceof RandomEvent) {
+            _matched=true;
+            this.randomEventsBuilder.add(((RandomEvent)event));
+          }
+        }
+        if (!_matched) {
+          throw new IllegalArgumentException(("Unknown event: " + event));
+        }
+        _xblockexpression = this;
+      }
+      return _xblockexpression;
+    }
+    
+    public EventCollection.Builder addAll(final EventCollection materializedEvens) {
+      EventCollection.Builder _xblockexpression = null;
+      {
+        int _falseEventCount = this.falseEventCount;
+        this.falseEventCount = (_falseEventCount + materializedEvens.falseEventCount);
+        int _trueEventCount = this.trueEventCount;
+        this.trueEventCount = (_trueEventCount + materializedEvens.trueEventCount);
+        this.randomEventsBuilder.addAll(materializedEvens.randomEvents);
+        _xblockexpression = this;
+      }
+      return _xblockexpression;
+    }
+    
+    public EventCollection build() {
+      ImmutableSet<RandomEvent> _build = this.randomEventsBuilder.build();
+      return new EventCollection(this.falseEventCount, this.trueEventCount, _build);
+    }
+  }
+  
+  private final int falseEventCount;
+  
+  private final int trueEventCount;
+  
+  private final Set<RandomEvent> randomEvents;
+  
+  public boolean containsFalseEvent() {
+    return (this.falseEventCount >= 1);
+  }
+  
+  public boolean containsTrueEvent() {
+    return (this.trueEventCount >= 1);
+  }
+  
+  public int getVariableEventCount() {
+    return this.randomEvents.size();
+  }
+  
+  public boolean containsRandomEvent() {
+    int _variableEventCount = this.getVariableEventCount();
+    return (_variableEventCount >= 1);
+  }
+  
+  public int getCount() {
+    int _variableEventCount = this.getVariableEventCount();
+    return ((this.falseEventCount + this.trueEventCount) + _variableEventCount);
+  }
+  
+  public boolean isEmpty() {
+    return (((!this.containsFalseEvent()) && (!this.containsTrueEvent())) && (!this.containsRandomEvent()));
+  }
+  
+  public boolean containsExactlyOneRandomEvent() {
+    return (((!this.containsFalseEvent()) && (!this.containsTrueEvent())) && (this.getVariableEventCount() == 1));
+  }
+  
+  public RandomEvent toSingleRandomEvent() {
+    RandomEvent _xblockexpression = null;
+    {
+      boolean _containsExactlyOneRandomEvent = this.containsExactlyOneRandomEvent();
+      boolean _not = (!_containsExactlyOneRandomEvent);
+      if (_not) {
+        throw new IllegalStateException("Input collection is not a single random event");
+      }
+      _xblockexpression = IterableExtensions.<RandomEvent>head(this.randomEvents);
+    }
+    return _xblockexpression;
+  }
+  
+  public static EventCollection.Builder builder() {
+    return new EventCollection.Builder();
+  }
+  
+  public EventCollection(final int falseEventCount, final int trueEventCount, final Set<RandomEvent> randomEvents) {
+    super();
+    this.falseEventCount = falseEventCount;
+    this.trueEventCount = trueEventCount;
+    this.randomEvents = randomEvents;
+  }
+  
+  @Override
+  @Pure
+  public int hashCode() {
+    final int prime = 31;
+    int result = 1;
+    result = prime * result + this.falseEventCount;
+    result = prime * result + this.trueEventCount;
+    return prime * result + ((this.randomEvents== null) ? 0 : this.randomEvents.hashCode());
+  }
+  
+  @Override
+  @Pure
+  public boolean equals(final Object obj) {
+    if (this == obj)
+      return true;
+    if (obj == null)
+      return false;
+    if (getClass() != obj.getClass())
+      return false;
+    EventCollection other = (EventCollection) obj;
+    if (other.falseEventCount != this.falseEventCount)
+      return false;
+    if (other.trueEventCount != this.trueEventCount)
+      return false;
+    if (this.randomEvents == null) {
+      if (other.randomEvents != null)
+        return false;
+    } else if (!this.randomEvents.equals(other.randomEvents))
+      return false;
+    return true;
+  }
+  
+  @Override
+  @Pure
+  public String toString() {
+    ToStringBuilder b = new ToStringBuilder(this);
+    b.add("falseEventCount", this.falseEventCount);
+    b.add("trueEventCount", this.trueEventCount);
+    b.add("randomEvents", this.randomEvents);
+    return b.toString();
+  }
+  
+  @Pure
+  public int getFalseEventCount() {
+    return this.falseEventCount;
+  }
+  
+  @Pure
+  public int getTrueEventCount() {
+    return this.trueEventCount;
+  }
+  
+  @Pure
+  public Set<RandomEvent> getRandomEvents() {
+    return this.randomEvents;
+  }
+}