Add files via upload

Author: kevinlano

Identifier.java

@@ -0,0 +1,20 @@
+/******************************
+* Copyright (c) 2003,2019 Kevin Lano
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 2.0 which is available at
+* http://www.eclipse.org/legal/epl-2.0
+*
+* SPDX-License-Identifier: EPL-2.0
+* *****************************/
+/* Package: Utilities */ 
+
+public class Identifier
+{ private static int count = 0;
+
+  public static String nextIdentifier(String pfx)
+  { String res = pfx + count;
+    count++;
+    return res;
+  }
+}
+

InPattern.java

@@ -0,0 +1,130 @@
+import java.util.Vector; 
+
+/******************************
+* Copyright (c) 2003,2019 Kevin Lano
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 2.0 which is available at
+* http://www.eclipse.org/legal/epl-2.0
+*
+* SPDX-License-Identifier: EPL-2.0
+* *****************************/
+/* Package: ATL */ 
+
+public class InPattern
+{ Vector elements; // of InPatternElement
+
+  public InPattern()
+  { elements = new Vector(); } 
+
+  public void setElements(Vector elems)
+  { elements = elems; } 
+
+  public void addElement(InPatternElement ipe) 
+  { elements.add(ipe); } 
+
+  public int size() 
+  { return elements.size(); } 
+
+  public String toString()
+  { String res = "from "; 
+    for (int i = 0; i < elements.size(); i++) 
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      res = res + "    " + ipe; 
+      if (i < elements.size() - 1) 
+      { res = res + ",\n"; } 
+    } 
+    return res; 
+  } 
+
+  public String firstType()  // Will become the owner of the constraint of the rule
+  { if (elements.size() > 0) 
+    { InPatternElement ipe = (InPatternElement) elements.get(0); 
+      return ipe.getType(); 
+    } 
+    return null; 
+  }
+
+  public Entity firstEntity()
+  { if (elements.size() > 0) 
+    { InPatternElement ipe = (InPatternElement) elements.get(0); 
+      Type typ = ipe.variable.getType();
+      if (typ.isEntity())
+      { return typ.getEntity(); }  
+    } 
+    return null; 
+  }
+
+  public boolean hasType(String typ) 
+  { // typ occurs as a type of the pattern, or superclass of such a type
+
+    for (int i = 0; i < elements.size(); i++)
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      if (typ.equals(ipe.variable.getType() + ""))
+      { return true; } 
+    } 
+    return false; 
+  } 
+
+  public Expression toExpression(UseCase uc)
+  { // pre: elements.size() > 0
+    if (elements.size() == 0) 
+    { return new BasicExpression(true); } 
+
+    InPatternElement ipe0 = (InPatternElement) elements.get(0);
+    Expression res = ipe0.condition; 
+    for (int i = 1; i < elements.size(); i++)
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      res = Expression.simplify("&",res,ipe.getFullCondition(uc),null);  
+    } 
+    return res; 
+  }  
+
+  public Vector allVariables()
+  { Vector res = new Vector(); 
+    for (int i = 0; i < elements.size(); i++)
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      if (ipe.variable != null) 
+      { res.add(ipe.variable); } 
+    } 
+    return res; 
+  }  
+
+  public int complexity() 
+  { int result = 0; 
+    for (int i = 0; i < elements.size(); i++) 
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      result = result + ipe.complexity(); 
+    } 
+    return result; 
+  } 
+
+  public int cyclomaticComplexity() 
+  { int result = 0; 
+    for (int i = 0; i < elements.size(); i++) 
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      result = result + ipe.cyclomaticComplexity(); 
+    } 
+    return result; 
+  } 
+
+  public Vector operationsUsedIn()
+  { Vector res = new Vector(); 
+    for (int i = 0; i < elements.size(); i++)
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      if (ipe.condition != null) 
+      { res.addAll(ipe.condition.allOperationsUsedIn()); } 
+    } 
+    return res; 
+  } 
+
+  public Vector getUses(String data)
+  { Vector res = new Vector(); 
+    for (int i = 0; i < elements.size(); i++)
+    { InPatternElement ipe = (InPatternElement) elements.get(i); 
+      if (ipe.condition != null) 
+      { res.addAll(ipe.condition.getUses(data)); } 
+    } 
+    return res; 
+  } 
+
+} 

InPatternElement.java

@@ -0,0 +1,58 @@
+import java.util.Vector; 
+
+/******************************
+* Copyright (c) 2003,2019 Kevin Lano
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 2.0 which is available at
+* http://www.eclipse.org/legal/epl-2.0
+*
+* SPDX-License-Identifier: EPL-2.0
+* *****************************/
+/* Package: ATL */ 
+
+
+public class InPatternElement
+{ Attribute variable; 
+  Expression condition; 
+
+  public InPatternElement(Attribute att, Expression exp)
+  { variable = att;
+    condition = exp;
+  } 
+
+  public String toString()
+  { String res = variable.getName() + " : MM1!" + variable.getType(); 
+    if (condition == null || "true".equals(condition + ""))
+    { return res; } 
+    return res + " ( " + condition + " )"; 
+  } 
+
+  public void setCondition(Expression cond)
+  { condition = cond; } 
+
+  public Expression getFullCondition(UseCase uc)
+  { BasicExpression be = new BasicExpression(variable.getName()); 
+    be.setType(variable.getType()); 
+    BasicExpression betype = new BasicExpression(variable.getType() + ""); 
+    Expression res = new BinaryExpression(":", be, betype);
+    Expression newcond = condition.replaceModuleReferences(uc);  
+    return Expression.simplify("&", res, newcond, null); 
+  } // need to convert the condition to remove "thisModule"
+
+  public String getType()
+  { return variable.getType() + ""; } 
+
+  public int complexity()
+  { int result = 2 + variable.getType().complexity(); 
+    if (condition != null) 
+    { result = result + condition.syntacticComplexity(); } 
+    return result; 
+  } 
+
+  public int cyclomaticComplexity()
+  { int result = 0; 
+    if (condition != null) 
+    { result = result + condition.cyclomaticComplexity(); } 
+    return result; 
+  } 
+}

Include.java

@@ -0,0 +1,66 @@
+import java.util.*; 
+import java.io.*; 
+
+/* package: UseCase */ 
+/******************************
+* Copyright (c) 2003,2019 Kevin Lano
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 2.0 which is available at
+* http://www.eclipse.org/legal/epl-2.0
+*
+* SPDX-License-Identifier: EPL-2.0
+* *****************************/
+
+public class Include extends ModelElement
+{ UseCase includingCase; 
+  UseCase addition; 
+
+  public Include(UseCase base, UseCase subusecase)
+  { super(""); 
+    includingCase = base; 
+    addition = subusecase; 
+  } 
+
+  public UseCase getInclusion()
+  { return addition; } 
+
+  public static String displayInclusions(List incls)
+  { String res = ""; 
+    for (int i = 0; i < incls.size(); i++) 
+    { Include ex = (Include) incls.get(i); 
+      res = res + ex.includingCase.getName() + " --includes--> " + 
+                  ex.addition.getName() + "\n"; 
+    } 
+    return res; 
+  } 
+
+  public UseCase insertIntoBase()
+  { UseCase result = includingCase; // (UseCase) includingCase.clone(); 
+    Vector extcons = addition.getPostconditions(); 
+    Vector extstats = addition.getCode().getStatements(); 
+
+    for (int i = 0; i < extcons.size(); i++) 
+    { Constraint extpost = (Constraint) extcons.get(i); 
+      result.addPostcondition(extpost); 
+      result.addStatement((Statement) extstats.get(i)); 
+    } 
+    // result.setName(includingCase.getName()); 
+    return result; 
+  } 
+  // also add extension preconditions to result preconditions
+
+  public static UseCase insertIntoBase(UseCase uc, UseCase inc)
+  { Vector extcons = inc.getPostconditions(); 
+    Vector extstats = inc.getCode().getStatements(); 
+
+    for (int i = 0; i < extcons.size(); i++) 
+    { Constraint extpost = (Constraint) extcons.get(i); 
+      uc.addPostcondition(extpost); 
+      uc.addStatement((Statement) extstats.get(i)); 
+    } 
+    // result.setName(includingCase.getName()); 
+    return uc; 
+  } 
+
+  public void generateJava(java.io.PrintWriter out) { } 
+}