1 files changed, 154 insertions, 0 deletions

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java
new file mode 100644
index 00000000..e59ef004
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java
@@ -0,0 +1,154 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.generator;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsFactory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Request;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class CpsGenerator {
+  @Extension
+  private final CpsFactory _cpsFactory = CpsFactory.eINSTANCE;
+  
+  private static final int MIN_MEMORY = 1;
+  
+  private static final int MAX_MEMORY = 6;
+  
+  private static final int MIN_HDD = 1;
+  
+  private static final int MAX_HDD = 30;
+  
+  private static final int HIGH_CPU_FRACTION = 4;
+  
+  private static final int MIN_REPLICAS = 1;
+  
+  private static final int MAX_REPLICAS = 4;
+  
+  private final Random random;
+  
+  private final int applicationTypeCount;
+  
+  private final int demandFactor;
+  
+  public CpsGenerator(final long randomSeed, final int applicationTypeCount, final int demandFactor) {
+    Random _random = new Random(randomSeed);
+    this.random = _random;
+    this.applicationTypeCount = applicationTypeCount;
+    this.demandFactor = demandFactor;
+  }
+  
+  public CyberPhysicalSystem generateCpsProblem() {
+    CyberPhysicalSystem _xblockexpression = null;
+    {
+      final ResourceSetImpl resourceSet = new ResourceSetImpl();
+      final Resource resource = resourceSet.createResource(URI.createFileURI("dummy.dummyext"));
+      CyberPhysicalSystem _createCyberPhysicalSystem = this._cpsFactory.createCyberPhysicalSystem();
+      final Procedure1<CyberPhysicalSystem> _function = (CyberPhysicalSystem it) -> {
+        final CyberPhysicalSystem cps = it;
+        EList<EObject> _contents = resource.getContents();
+        _contents.add(cps);
+        this.createLowCpuHostTypes(it);
+        final List<HostType> highCpuHostTypes = this.createHighCpuHostTypes(it);
+        for (int i = 0; (i < this.applicationTypeCount); i++) {
+          if (((i % CpsGenerator.HIGH_CPU_FRACTION) == 0)) {
+            this.createRandomApplicationType(it, highCpuHostTypes);
+          } else {
+            this.createRandomApplicationType(it, it.getHostTypes());
+          }
+        }
+        for (int i = 0; (i < this.demandFactor); i++) {
+          EList<Request> _requests = it.getRequests();
+          Request _createRequest = this._cpsFactory.createRequest();
+          final Procedure1<Request> _function_1 = (Request it_1) -> {
+            EList<ApplicationType> _applicationTypes = cps.getApplicationTypes();
+            for (final ApplicationType appType : _applicationTypes) {
+              EList<Requirement> _requirements = it_1.getRequirements();
+              Requirement _createRequirement = this._cpsFactory.createRequirement();
+              final Procedure1<Requirement> _function_2 = (Requirement it_2) -> {
+                it_2.setCount(this.nextInt(CpsGenerator.MIN_REPLICAS, CpsGenerator.MAX_REPLICAS));
+                it_2.setType(appType);
+              };
+              Requirement _doubleArrow = ObjectExtensions.<Requirement>operator_doubleArrow(_createRequirement, _function_2);
+              _requirements.add(_doubleArrow);
+            }
+          };
+          Request _doubleArrow = ObjectExtensions.<Request>operator_doubleArrow(_createRequest, _function_1);
+          _requests.add(_doubleArrow);
+        }
+      };
+      _xblockexpression = ObjectExtensions.<CyberPhysicalSystem>operator_doubleArrow(_createCyberPhysicalSystem, _function);
+    }
+    return _xblockexpression;
+  }
+  
+  private void createRandomApplicationType(final CyberPhysicalSystem it, final Collection<HostType> allowedHostTypes) {
+    final ApplicationType appType = this._cpsFactory.createApplicationType();
+    final int memory = this.nextInt(CpsGenerator.MIN_MEMORY, CpsGenerator.MAX_MEMORY);
+    final int hdd = this.nextInt(CpsGenerator.MIN_HDD, CpsGenerator.MAX_HDD);
+    for (final HostType hostType : allowedHostTypes) {
+      EList<ResourceRequirement> _requirements = appType.getRequirements();
+      ResourceRequirement _createResourceRequirement = this._cpsFactory.createResourceRequirement();
+      final Procedure1<ResourceRequirement> _function = (ResourceRequirement it_1) -> {
+        it_1.setHostType(hostType);
+        it_1.setRequiredMemory(memory);
+        it_1.setRequiredHdd(hdd);
+      };
+      ResourceRequirement _doubleArrow = ObjectExtensions.<ResourceRequirement>operator_doubleArrow(_createResourceRequirement, _function);
+      _requirements.add(_doubleArrow);
+    }
+    EList<ApplicationType> _applicationTypes = it.getApplicationTypes();
+    _applicationTypes.add(appType);
+  }
+  
+  private List<HostType> createLowCpuHostTypes(final CyberPhysicalSystem it) {
+    HostType _createHostType = this.createHostType(it, 2, 8, 75);
+    HostType _createHostType_1 = this.createHostType(it, 4, 16, 150);
+    HostType _createHostType_2 = this.createHostType(it, 3, 16, 75);
+    HostType _createHostType_3 = this.createHostType(it, 6, 32, 150);
+    return Collections.<HostType>unmodifiableList(CollectionLiterals.<HostType>newArrayList(_createHostType, _createHostType_1, _createHostType_2, _createHostType_3));
+  }
+  
+  private List<HostType> createHighCpuHostTypes(final CyberPhysicalSystem it) {
+    HostType _createHostType = this.createHostType(it, 2, 4, 50);
+    HostType _createHostType_1 = this.createHostType(it, 4, 8, 100);
+    return Collections.<HostType>unmodifiableList(CollectionLiterals.<HostType>newArrayList(_createHostType, _createHostType_1));
+  }
+  
+  private HostType createHostType(final CyberPhysicalSystem it, final int cost, final int memory, final int hdd) {
+    HostType _xblockexpression = null;
+    {
+      HostType _createHostType = this._cpsFactory.createHostType();
+      final Procedure1<HostType> _function = (HostType it_1) -> {
+        it_1.setCost(cost);
+        it_1.setDefaultMemory(memory);
+        it_1.setDefaultHdd(hdd);
+      };
+      final HostType hostType = ObjectExtensions.<HostType>operator_doubleArrow(_createHostType, _function);
+      EList<HostType> _hostTypes = it.getHostTypes();
+      _hostTypes.add(hostType);
+      _xblockexpression = hostType;
+    }
+    return _xblockexpression;
+  }
+  
+  private int nextInt(final int lower, final int upper) {
+    int _nextInt = this.random.nextInt(((upper - lower) + 1));
+    return (lower + _nextInt);
+  }
+}