/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_FixmlAttributes1.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Mentor Attributes
  private int id;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor(int aId)
  {
    id = aId;
  }

  public Mentor()
  {
  }


  //------------------------
  // INTERFACE
  //------------------------

  public boolean setId(int aId)
  {
    boolean wasSet = false;
    id = aId;
    wasSet = true;
    return wasSet;
  }

  public int getId()
  {
    return id;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "id" + ":" + getId()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_FixmlAttributes2.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Mentor Attributes
  private String capacity;
  private int id;
  private String name;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor(String aCapacity, int aId, String aName)
  {
    capacity = aCapacity;
    id = aId;
    name = aName;
  }

  public Mentor()
  {
    capacity = "31";
    name = "Umple";
  }


  //------------------------
  // INTERFACE
  //------------------------

  public boolean setCapacity(String aCapacity)
  {
    boolean wasSet = false;
    capacity = aCapacity;
    wasSet = true;
    return wasSet;
  }

  public boolean setId(int aId)
  {
    boolean wasSet = false;
    id = aId;
    wasSet = true;
    return wasSet;
  }

  public boolean setName(String aName)
  {
    boolean wasSet = false;
    name = aName;
    wasSet = true;
    return wasSet;
  }

  public String getCapacity()
  {
    return capacity;
  }

  public int getId()
  {
    return id;
  }

  public String getName()
  {
    return name;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "capacity" + ":" + getCapacity()+ "," +
            "id" + ":" + getId()+ "," +
            "name" + ":" + getName()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_FixmlAttributes3.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Mentor Attributes
  private String capacity;
  private int id;
  private String name;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor(String aCapacity, int aId, String aName)
  {
    capacity = aCapacity;
    id = aId;
    name = aName;
  }

  public Mentor()
  {
    capacity = "31";
    name = "Umple";
    System.out.println("Testing");
    String test;
  }


  //------------------------
  // INTERFACE
  //------------------------

  public boolean setCapacity(String aCapacity)
  {
    boolean wasSet = false;
    capacity = aCapacity;
    wasSet = true;
    return wasSet;
  }

  public boolean setId(int aId)
  {
    boolean wasSet = false;
    id = aId;
    wasSet = true;
    return wasSet;
  }

  public boolean setName(String aName)
  {
    boolean wasSet = false;
    name = aName;
    wasSet = true;
    return wasSet;
  }

  public String getCapacity()
  {
    return capacity;
  }

  public int getId()
  {
    return id;
  }

  public String getName()
  {
    return name;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "capacity" + ":" + getCapacity()+ "," +
            "id" + ":" + getId()+ "," +
            "name" + ":" + getName()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
  public String foo(int a){
    // line 22 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
    System.out.println("Starting foo...");
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {      
      // line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
      System.out.println("Returning from foo, a: " + a);
      // END OF UMPLE AFTER INJECTION
      return 4;
    }    
    // line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
    System.out.println("Returning from foo, a: " + a);
    // END OF UMPLE AFTER INJECTION
    return 3;

  }

  // line 11 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
  public String foo(int a, String b){
    // line 22 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
    System.out.println("Starting foo...");
    // END OF UMPLE BEFORE INJECTION
    if(a > 0 && "".equals(b)) {      
      // line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
      System.out.println("Returning from foo, a: " + a);
      // END OF UMPLE AFTER INJECTION
      return 3;
    }    
    // line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
    System.out.println("Returning from foo, a: " + a);
    // END OF UMPLE AFTER INJECTION
    return 1;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_Generated.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 6 "../ClassTemplateTest_Generated.ump"
   public static  void main(String [] args){
    Thread.currentThread().setUncaughtExceptionHandler(new UmpleExceptionHandler());
    Thread.setDefaultUncaughtExceptionHandler(new UmpleExceptionHandler());
    
  }

  public static class UmpleExceptionHandler implements Thread.UncaughtExceptionHandler
  {
    public void uncaughtException(Thread t, Throwable e)
    {
      translate(e);
      if(e.getCause()!=null)
      {
        translate(e.getCause());
      }
      e.printStackTrace();
    }
    public void translate(Throwable e)
    {
      java.util.List<StackTraceElement> result = new java.util.ArrayList<StackTraceElement>();
      StackTraceElement[] elements = e.getStackTrace();
      try
      {
        for(StackTraceElement element:elements)
        {
          String className = element.getClassName();
          String methodName = element.getMethodName();
          boolean methodFound = false;
          int index = className.lastIndexOf('.')+1;
          try {
            java.lang.reflect.Method query = this.getClass().getMethod(className.substring(index)+"_"+methodName,new Class[]{});
            UmpleSourceData sourceInformation = (UmpleSourceData)query.invoke(this,new Object[]{});
            for(int i=0;i<sourceInformation.size();++i)
            {
              // To compensate for any offsets caused by injected code we need to loop through the other references to this function
              //  and adjust the start / length of the function.
              int functionStart = sourceInformation.getJavaLine(i) + (("main".equals(methodName))?3:1);
              int functionEnd = functionStart + sourceInformation.getLength(i);
              int afterInjectionLines = 0;
              //  We can leverage the fact that all inject statements are added to the uncaught exception list 
              //   before the functions that they are within
              for (int j = 0; j < i; j++) {
                if (sourceInformation.getJavaLine(j) - 1 >= functionStart &&
                    sourceInformation.getJavaLine(j) - 1 <= functionEnd &&
                    sourceInformation.getJavaLine(j) - 1 <= element.getLineNumber()) {
                    // A before injection, +2 for the comments surrounding the injected code
                    if (sourceInformation.getJavaLine(j) - 1 == functionStart) {
                        functionStart += sourceInformation.getLength(j) + 2;
                        functionEnd += sourceInformation.getLength(j) + 2;
                    } else {
                        // An after injection
                        afterInjectionLines += sourceInformation.getLength(j) + 2;
                        functionEnd += sourceInformation.getLength(j) + 2;
                    }
                }
              }
              int distanceFromStart = element.getLineNumber() - functionStart - afterInjectionLines;
              if(distanceFromStart>=0&&distanceFromStart<=sourceInformation.getLength(i))
              {
                result.add(new StackTraceElement(element.getClassName(),element.getMethodName(),sourceInformation.getFileName(i),sourceInformation.getUmpleLine(i)+distanceFromStart));
                methodFound = true;
                break;
              }
            }
          }
          catch (Exception e2){}
          if(!methodFound)
          {
            result.add(element);
          }
        }
      }
      catch (Exception e1)
      {
        e1.printStackTrace();
      }
      e.setStackTrace(result.toArray(new StackTraceElement[0]));
    }
  //The following methods Map Java lines back to their original Umple file / line    
    public UmpleSourceData Mentor_main(){ return new UmpleSourceData().setFileNames("ClassTemplateTest_Generated.ump").setUmpleLines(5).setJavaLines(28).setLengths(1);}

  }
  public static class UmpleSourceData
  {
    String[] umpleFileNames;
    Integer[] umpleLines;
    Integer[] umpleJavaLines;
    Integer[] umpleLengths;
    
    public UmpleSourceData(){
    }
    public String getFileName(int i){
      return umpleFileNames[i];
    }
    public Integer getUmpleLine(int i){
      return umpleLines[i];
    }
    public Integer getJavaLine(int i){
      return umpleJavaLines[i];
    }
    public Integer getLength(int i){
      return umpleLengths[i];
    }
    public UmpleSourceData setFileNames(String... filenames){
      umpleFileNames = filenames;
      return this;
    }
    public UmpleSourceData setUmpleLines(Integer... umplelines){
      umpleLines = umplelines;
      return this;
    }
    public UmpleSourceData setJavaLines(Integer... javalines){
      umpleJavaLines = javalines;
      return this;
    }
    public UmpleSourceData setLengths(Integer... lengths){
      umpleLengths = lengths;
      return this;
    }
    public int size(){
      return umpleFileNames.length;
    }
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 11 "../ClassTemplateTest_Generated5.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 15 "../ClassTemplateTest_Generated5.ump"
   public static  void main(String [] args){
    Thread.currentThread().setUncaughtExceptionHandler(new example.Student.UmpleExceptionHandler());
    Thread.setDefaultUncaughtExceptionHandler(new example.Student.UmpleExceptionHandler());
    /* Class Teacher main */
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_Generated2.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 6 "../ClassTemplateTest_Generated2.ump"
   public void main(String [] args){
    
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_Generated3.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 6 "../ClassTemplateTest_Generated3.ump"
   public static  void main(){
    
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_Generated3.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 6 "../ClassTemplateTest_Generated3.ump"
   public static  void main(){
    
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../TestUmpleEnumerations.ump"
public class Student
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Status { FullTime, PartTime }
  public enum Grade { High }
  public enum RelationshipStatus { Single, Married, Divorced }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;
import java.util.*;

// line 3 "../TestUmpleEnumerations_2.ump"
public class X
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Colour { Red, Blue, Green }

  //------------------------
  // STATIC VARIABLES
  //------------------------

  public static final int MY_CONST = 100;
  private static Map<String, X> xsByMyName = new HashMap<String, X>();

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //X Attributes
  private String myName;
  private String defaultAttr;

  //X State Machines
  public enum Sm { s1, s2 }
  private Sm sm;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public X(String aDefaultAttr)
  {
    defaultAttr = aDefaultAttr;
    if (!setMyName(aMyName))
    {
      throw new RuntimeException("Cannot create due to duplicate myName. See https://manual.umple.org?RE003ViolationofUniqueness.html");
    }
    setSm(Sm.s1);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setMyName(String aMyName)
  {
    boolean wasSet = false;
    String anOldMyName = getMyName();
    if (anOldMyName != null && anOldMyName.equals(aMyName)) {
      return true;
    }
    if (hasWithMyName(aMyName)) {
      return wasSet;
    }
    myName = aMyName;
    wasSet = true;
    if (anOldMyName != null) {
      xsByMyName.remove(anOldMyName);
    }
    xsByMyName.put(aMyName, this);
    return wasSet;
  }

  public boolean setDefaultAttr(String aDefaultAttr)
  {
    boolean wasSet = false;
    defaultAttr = aDefaultAttr;
    wasSet = true;
    return wasSet;
  }

  public String getMyName()
  {
    return myName;
  }
  /* Code from template attribute_GetUnique */
  public static X getWithMyName(String aMyName)
  {
    return xsByMyName.get(aMyName);
  }
  /* Code from template attribute_HasUnique */
  public static boolean hasWithMyName(String aMyName)
  {
    return getWithMyName(aMyName) != null;
  }

  public String getDefaultAttr()
  {
    return defaultAttr;
  }

  public String getSmFullName()
  {
    String answer = sm.toString();
    return answer;
  }

  public Sm getSm()
  {
    return sm;
  }

  public boolean goToS2()
  {
    boolean wasEventProcessed = false;
    
    Sm aSm = sm;
    switch (aSm)
    {
      case s1:
        setSm(Sm.s2);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  private void setSm(Sm aSm)
  {
    sm = aSm;
  }

  public void delete()
  {
    xsByMyName.remove(getMyName());
  }


  public String toString()
  {
    return super.toString() + "["+
            "myName" + ":" + getMyName()+ "," +
            "defaultAttr" + ":" + getDefaultAttr()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 6 "../TestUmpleEnumerations_3.ump"
public class C1
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Status { Married, Single, Divorced }
  public enum Gender { Male, Female }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //C1 Attributes
  private Status status;
  private Gender gender;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public C1(Status aStatus, Gender aGender)
  {
    status = aStatus;
    gender = aGender;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setStatus(Status aStatus)
  {
    boolean wasSet = false;
    status = aStatus;
    wasSet = true;
    return wasSet;
  }

  public boolean setGender(Gender aGender)
  {
    boolean wasSet = false;
    gender = aGender;
    wasSet = true;
    return wasSet;
  }

  public Status getStatus()
  {
    return status;
  }

  public Gender getGender()
  {
    return gender;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "status" + "=" + (getStatus() != null ? !getStatus().equals(this)  ? getStatus().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "gender" + "=" + (getGender() != null ? !getGender().equals(this)  ? getGender().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 11 "../TestUmpleEnumerations_3.ump"
public class C2
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Status { Married, Single, Divorced }
  public enum Gender { Male, Female }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //C2 Attributes
  private Status status;
  private Gender gender;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public C2(Status aStatus, Gender aGender)
  {
    status = aStatus;
    gender = aGender;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setStatus(Status aStatus)
  {
    boolean wasSet = false;
    status = aStatus;
    wasSet = true;
    return wasSet;
  }

  public boolean setGender(Gender aGender)
  {
    boolean wasSet = false;
    gender = aGender;
    wasSet = true;
    return wasSet;
  }

  public Status getStatus()
  {
    return status;
  }

  public Gender getGender()
  {
    return gender;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "status" + "=" + (getStatus() != null ? !getStatus().equals(this)  ? getStatus().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "gender" + "=" + (getGender() != null ? !getGender().equals(this)  ? getGender().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 5 "../TestUmpleEnumerations_4.ump"
public class C1
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Status { Married, Single, Divorced }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //C1 Attributes
  private Status status;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public C1(Status aStatus)
  {
    status = aStatus;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setStatus(Status aStatus)
  {
    boolean wasSet = false;
    status = aStatus;
    wasSet = true;
    return wasSet;
  }

  public Status getStatus()
  {
    return status;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "status" + "=" + (getStatus() != null ? !getStatus().equals(this)  ? getStatus().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 9 "../TestUmpleEnumerations_4.ump"
public class C2
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Status { Married, Single, Divorced }
  public enum Gender { Male, Female }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //C2 Attributes
  private Gender gender;
  private Status status;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public C2(Gender aGender, Status aStatus)
  {
    gender = aGender;
    status = aStatus;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setGender(Gender aGender)
  {
    boolean wasSet = false;
    gender = aGender;
    wasSet = true;
    return wasSet;
  }

  public boolean setStatus(Status aStatus)
  {
    boolean wasSet = false;
    status = aStatus;
    wasSet = true;
    return wasSet;
  }

  public Gender getGender()
  {
    return gender;
  }

  public Status getStatus()
  {
    return status;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "gender" + "=" + (getGender() != null ? !getGender().equals(this)  ? getGender().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "status" + "=" + (getStatus() != null ? !getStatus().equals(this)  ? getStatus().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 6 "../TestUmpleEnumerations_5.ump"
public class X1
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Month { January, February, March }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //X1 Attributes
  private Month month;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public X1(Month aMonth)
  {
    month = aMonth;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setMonth(Month aMonth)
  {
    boolean wasSet = false;
    month = aMonth;
    wasSet = true;
    return wasSet;
  }

  public Month getMonth()
  {
    return month;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "month" + "=" + (getMonth() != null ? !getMonth().equals(this)  ? getMonth().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 10 "../TestUmpleEnumerations_5.ump"
public class X2
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Fruit { Apple, Orange }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //X2 Attributes
  private Fruit t;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public X2(Fruit aT)
  {
    t = aT;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setT(Fruit aT)
  {
    boolean wasSet = false;
    t = aT;
    wasSet = true;
    return wasSet;
  }

  public Fruit getT()
  {
    return t;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "t" + "=" + (getT() != null ? !getT().equals(this)  ? getT().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 6 "../TestUmpleEnumerations_6.ump"
public class X
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public X()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 1 "../TestUmpleEnumerations_6.ump"
public class X2
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public X2()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 5 "../TestUmpleEnumerations_7.ump"
public class X
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Month { Jan, Feb, Mar }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public X()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 6 "../TestUmpleEnumerations_7.ump"
  public String displayMonth(Month m){
    return(m.toString())
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 9 "../TestUmpleEnumerations_7.ump"
public class Y
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Month { Jan, Feb, Mar }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Y State Machines
  public enum Sm { s1, s2 }
  private Sm sm;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Y()
  {
    setSm(Sm.s1);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public String getSmFullName()
  {
    String answer = sm.toString();
    return answer;
  }

  public Sm getSm()
  {
    return sm;
  }

  public boolean goToS2(Month m)
  {
    boolean wasEventProcessed = false;
    
    Sm aSm = sm;
    switch (aSm)
    {
      case s1:
        // line 12 "../TestUmpleEnumerations_7.ump"
        System.out.println(m);
        setSm(Sm.s2);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  private void setSm(Sm aSm)
  {
    sm = aSm;
  }

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 18 "../TestUmpleEnumerations_7.ump"
public class Z
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Month { Jan, Feb, Mar }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Z()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 19 "../TestUmpleEnumerations_7.ump"
  public Month getBirthMonth(){
    return Month.Jan;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 7 "../TestUmpleEnumerations_8.ump"
public class A
{

  //------------------------
  // ENUMERATIONS
  //------------------------

  public enum Month { O, P, Q }

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //A Attributes
  private Month m;
  private Month p;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public A(Month aM, Month aP)
  {
    m = aM;
    p = aP;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setM(Month aM)
  {
    boolean wasSet = false;
    m = aM;
    wasSet = true;
    return wasSet;
  }

  public boolean setP(Month aP)
  {
    boolean wasSet = false;
    p = aP;
    wasSet = true;
    return wasSet;
  }

  public Month getM()
  {
    return m;
  }

  public Month getP()
  {
    return p;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "m" + "=" + (getM() != null ? !getM().equals(this)  ? getM().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "p" + "=" + (getP() != null ? !getP().equals(this)  ? getP().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 2 "../ImmutableNotLazyAttributeConstructor.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Student Attributes
  private String number;
  private String number2;

  //Helper Variables
  private boolean canSetNumber2;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student(String aNumber)
  {
    number = aNumber;
    canSetNumber2 = true;
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template attribute_SetImmutable */
  public boolean setNumber2(String aNumber2)
  {
    boolean wasSet = false;
    if (!canSetNumber2) { return false; }
    canSetNumber2 = false;
    number2 = aNumber2;
    wasSet = true;
    return wasSet;
  }

  public String getNumber()
  {
    return number;
  }

  public String getNumber2()
  {
    return number2;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "number" + ":" + getNumber()+ "," +
            "number2" + ":" + getNumber2()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_InternalConstant.ump"
public class Student
{ 
  //------------------------
  // STATIC VARIABLES
  //------------------------
 
private static final String Name = "XYZ";


  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;
import java.util.*;

// line 3 "../CascadeDelete.ump"
public class B
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //B Associations
  private List<C> myC;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public B()
  {
    myC = new ArrayList<C>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public C getMyC(int index)
  {
    C aMyC = myC.get(index);
    return aMyC;
  }

  public List<C> getMyC()
  {
    List<C> newMyC = Collections.unmodifiableList(myC);
    return newMyC;
  }

  public int numberOfMyC()
  {
    int number = myC.size();
    return number;
  }

  public boolean hasMyC()
  {
    boolean has = myC.size() > 0;
    return has;
  }

  public int indexOfMyC(C aMyC)
  {
    int index = myC.indexOf(aMyC);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfMyC()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public C addMyC(D aMyD)
  {
    return new C(aMyD, this);
  }

  public boolean addMyC(C aMyC)
  {
    boolean wasAdded = false;
    if (myC.contains(aMyC)) { return false; }
    B existingB = aMyC.getB();
    boolean isNewB = existingB != null && !this.equals(existingB);
    if (isNewB)
    {
      aMyC.setB(this);
    }
    else
    {
      myC.add(aMyC);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeMyC(C aMyC)
  {
    boolean wasRemoved = false;
    //Unable to remove aMyC, as it must always have a b
    if (!this.equals(aMyC.getB()))
    {
      myC.remove(aMyC);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addMyCAt(C aMyC, int index)
  {  
    boolean wasAdded = false;
    if(addMyC(aMyC))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMyC()) { index = numberOfMyC() - 1; }
      myC.remove(aMyC);
      myC.add(index, aMyC);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveMyCAt(C aMyC, int index)
  {
    boolean wasAdded = false;
    if(myC.contains(aMyC))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMyC()) { index = numberOfMyC() - 1; }
      myC.remove(aMyC);
      myC.add(index, aMyC);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addMyCAt(aMyC, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    while (myC.size() > 0)
    {
      C aMyC = myC.get(myC.size() - 1);
      aMyC.delete();
      myC.remove(aMyC);
    }
    
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 6 "../CascadeDelete.ump"
public class C
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //C Associations
  private D myD;
  private B b;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public C(D aMyD, B aB)
  {
    if (aMyD == null || aMyD.getC() != null)
    {
      throw new RuntimeException("Unable to create C due to aMyD. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    myD = aMyD;
    boolean didAddB = setB(aB);
    if (!didAddB)
    {
      throw new RuntimeException("Unable to create myC due to b. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
  }

  public C(B aB)
  {
    myD = new D(this);
    boolean didAddB = setB(aB);
    if (!didAddB)
    {
      throw new RuntimeException("Unable to create myC due to b. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetOne */
  public D getMyD()
  {
    return myD;
  }
  /* Code from template association_GetOne */
  public B getB()
  {
    return b;
  }
  /* Code from template association_SetOneToMany */
  public boolean setB(B aB)
  {
    boolean wasSet = false;
    if (aB == null)
    {
      return wasSet;
    }

    B existingB = b;
    b = aB;
    if (existingB != null && !existingB.equals(aB))
    {
      existingB.removeMyC(this);
    }
    b.addMyC(this);
    wasSet = true;
    return wasSet;
  }

  public void delete()
  {
    D existingMyD = myD;
    myD = null;
    if (existingMyD != null)
    {
      existingMyD.delete();
    }
    B placeholderB = b;
    this.b = null;
    if(placeholderB != null)
    {
      placeholderB.removeMyC(this);
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 1 "../CascadeDelete.ump"
public class D
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //D Associations
  private C c;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public D(C aC)
  {
    if (aC == null || aC.getMyD() != null)
    {
      throw new RuntimeException("Unable to create D due to aC. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    c = aC;
  }

  public D(B aBForC)
  {
    c = new C(this, aBForC);
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetOne */
  public C getC()
  {
    return c;
  }

  public void delete()
  {
    C existingC = c;
    c = null;
    if (existingC != null)
    {
      existingC.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 7 "ClassTemplateTest_StateMachineDoesNotImplementInterface.ump"
public class FileLogger implements Logger
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //FileLogger Attributes
  private String fileName;

  //FileLogger State Machines
  public enum Status { disconnected, connected }
  private Status status;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public FileLogger(String aFileName)
  {
    fileName = aFileName;
    setStatus(Status.disconnected);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public String getStatusFullName()
  {
    String answer = status.toString();
    return answer;
  }

  public Status getStatus()
  {
    return status;
  }

  public boolean attemptConnection()
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case disconnected:
        setStatus(Status.connected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  public boolean signalDisconnect()
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case connected:
        setStatus(Status.disconnected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  public boolean communicate(String message)
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case connected:
        setStatus(Status.connected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  private void setStatus(Status aStatus)
  {
    status = aStatus;
  }

  public void delete()
  {}

  @Override
  public boolean connect(){
          return false;
  }

  @Override
  public boolean disconnect(){
          return false;
  }

  @Override
  public boolean write(String data){
          return false;
  }


  public String toString()
  {
    return super.toString() + "["+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsComments.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsComments.ump"
  public String foo(int a){
    // line 25 "ClassTemplateTest_CodeInjectionsComments.ump"
    System.out.println("Starting foo with argument: " + a);
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {
      /*
        {
      */      
      // line 29 "ClassTemplateTest_CodeInjectionsComments.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 0;
    }
    else if(a == 1) {
      // foo()      
      // line 29 "ClassTemplateTest_CodeInjectionsComments.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return -1;
    }
    else {
      // {      
      // line 29 "ClassTemplateTest_CodeInjectionsComments.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 4;
    }

    for(int i = 0; i < a; i++) {
      // TODO: call foo()
      if(i == a/4) {        
        // line 29 "ClassTemplateTest_CodeInjectionsComments.ump"
        System.out.println("Returning from foo!");
        // END OF UMPLE AFTER INJECTION
        return a;
      }
    }    
    // line 29 "ClassTemplateTest_CodeInjectionsComments.ump"
    System.out.println("Returning from foo!");
    // END OF UMPLE AFTER INJECTION
    return 4;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package enumerations;
import java.util.*;

// line 3 "../TestUmpleEnumerations_innerQualified_1.ump"
public class Driver
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Driver Associations
  private List<DriverSchedule> driverSchedules;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Driver()
  {
    driverSchedules = new ArrayList<DriverSchedule>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public DriverSchedule getDriverSchedule(int index)
  {
    DriverSchedule aDriverSchedule = driverSchedules.get(index);
    return aDriverSchedule;
  }

  public List<DriverSchedule> getDriverSchedules()
  {
    List<DriverSchedule> newDriverSchedules = Collections.unmodifiableList(driverSchedules);
    return newDriverSchedules;
  }

  public int numberOfDriverSchedules()
  {
    int number = driverSchedules.size();
    return number;
  }

  public boolean hasDriverSchedules()
  {
    boolean has = driverSchedules.size() > 0;
    return has;
  }

  public int indexOfDriverSchedule(DriverSchedule aDriverSchedule)
  {
    int index = driverSchedules.indexOf(aDriverSchedule);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfDriverSchedules()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public DriverSchedule addDriverSchedule(DriverSchedule.Shift aShift, DriverSchedule.Status aStatus)
  {
    return new DriverSchedule(aShift, aStatus, this);
  }

  public boolean addDriverSchedule(DriverSchedule aDriverSchedule)
  {
    boolean wasAdded = false;
    if (driverSchedules.contains(aDriverSchedule)) { return false; }
    Driver existingDriver = aDriverSchedule.getDriver();
    boolean isNewDriver = existingDriver != null && !this.equals(existingDriver);
    if (isNewDriver)
    {
      aDriverSchedule.setDriver(this);
    }
    else
    {
      driverSchedules.add(aDriverSchedule);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeDriverSchedule(DriverSchedule aDriverSchedule)
  {
    boolean wasRemoved = false;
    //Unable to remove aDriverSchedule, as it must always have a driver
    if (!this.equals(aDriverSchedule.getDriver()))
    {
      driverSchedules.remove(aDriverSchedule);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addDriverScheduleAt(DriverSchedule aDriverSchedule, int index)
  {  
    boolean wasAdded = false;
    if(addDriverSchedule(aDriverSchedule))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfDriverSchedules()) { index = numberOfDriverSchedules() - 1; }
      driverSchedules.remove(aDriverSchedule);
      driverSchedules.add(index, aDriverSchedule);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveDriverScheduleAt(DriverSchedule aDriverSchedule, int index)
  {
    boolean wasAdded = false;
    if(driverSchedules.contains(aDriverSchedule))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfDriverSchedules()) { index = numberOfDriverSchedules() - 1; }
      driverSchedules.remove(aDriverSchedule);
      driverSchedules.add(index, aDriverSchedule);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addDriverScheduleAt(aDriverSchedule, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=driverSchedules.size(); i > 0; i--)
    {
      DriverSchedule aDriverSchedule = driverSchedules.get(i - 1);
      aDriverSchedule.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 4 "../ClassTemplateTest_Java.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsBasic.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsBasic.ump"
  public String foo(int a){
    // line 17 "ClassTemplateTest_CodeInjectionsBasic.ump"
    System.out.println("Starting foo with argument: " + a);
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {      
      // line 21 "ClassTemplateTest_CodeInjectionsBasic.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 0;
    }

    for(int i = 0; i < a; i++) {
      if(i == a/4) {        
        // line 21 "ClassTemplateTest_CodeInjectionsBasic.ump"
        System.out.println("Returning from foo!");
        // END OF UMPLE AFTER INJECTION
        return a;
      }
    }    
    // line 21 "ClassTemplateTest_CodeInjectionsBasic.ump"
    System.out.println("Returning from foo!");
    // END OF UMPLE AFTER INJECTION
    return 4;

  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
  public String foo(int a){
    // line 26 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
    System.out.println("Starting foo...");
    // END OF UMPLE BEFORE INJECTION
    // line 38 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
    System.out.println("Starting execution...");
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {
      return 4;
    }

    return 3;
  }

  // line 11 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
  public String foo(int a, String b){
    // line 26 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
    System.out.println("Starting foo...");
    // END OF UMPLE BEFORE INJECTION
    if(a > 0 && "".equals(b)) {      
      // line 30 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
      System.out.println("Returning from foo, a: " + a ", b: " + b);
      // END OF UMPLE AFTER INJECTION
      return 3;
    }    
    // line 30 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
    System.out.println("Returning from foo, a: " + a ", b: " + b);
    // END OF UMPLE AFTER INJECTION
    return 1;
  }

  // line 18 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
  public String bar(){
    // line 34 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
    // TODO: fix asap
    // END OF UMPLE BEFORE INJECTION
    // line 38 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
    System.out.println("Starting execution...");
    // END OF UMPLE BEFORE INJECTION
    int a = 4;

    if(a == 3) return 2;
    
    return 1;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
  public String foo(int a){
    // line 18 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
    System.out.println("Starting foo with argument: " + a);
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {      
      // line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 0;
    }
    else if(a == 1) {      
      // line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return -1;
    }
    else {      
      // line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 4;
    }

    for(int i = 0; i < a; i++)
      if(i == a/4) {        
        // line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
        System.out.println("Returning from foo!");
        // END OF UMPLE AFTER INJECTION
        return a;
      }    
    // line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
    System.out.println("Returning from foo!");
    // END OF UMPLE AFTER INJECTION
    return 4;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example.one;
import example.two.*;

// line 3 "../../ClassTemplateTest_Import.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Mentor Attributes
  private String name;

  //Mentor Associations
  private Student student;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor(String aName)
  {
    name = aName;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setName(String aName)
  {
    boolean wasSet = false;
    name = aName;
    wasSet = true;
    return wasSet;
  }

  public String getName()
  {
    return name;
  }
  /* Code from template association_GetOne */
  public Student getStudent()
  {
    return student;
  }

  public boolean hasStudent()
  {
    boolean has = student != null;
    return has;
  }
  /* Code from template association_SetOptionalOneToMandatoryMany */
  public boolean setStudent(Student aStudent)
  {
    //
    // This source of this source generation is association_SetOptionalOneToMandatoryMany.jet
    // This set file assumes the generation of a maximumNumberOfXXX method does not exist because 
    // it's not required (No upper bound)
    //   
    boolean wasSet = false;
    Student existingStudent = student;

    if (existingStudent == null)
    {
      if (aStudent != null)
      {
        if (aStudent.addMentor(this))
        {
          existingStudent = aStudent;
          wasSet = true;
        }
      }
    } 
    else if (existingStudent != null)
    {
      if (aStudent == null)
      {
        if (existingStudent.minimumNumberOfMentors() < existingStudent.numberOfMentors())
        {
          existingStudent.removeMentor(this);
          existingStudent = aStudent;  // aStudent == null
          wasSet = true;
        }
      } 
      else
      {
        if (existingStudent.minimumNumberOfMentors() < existingStudent.numberOfMentors())
        {
          existingStudent.removeMentor(this);
          aStudent.addMentor(this);
          existingStudent = aStudent;
          wasSet = true;
        }
      }
    }
    if (wasSet)
    {
      student = existingStudent;
    }
    return wasSet;
  }
  
  public void delete()
  {
    if (student != null)
    {
      if (student.numberOfMentors() <= 1)
      {
        student.delete();
      }
      else
      {
        Student placeholderStudent = student;
        this.student = null;
        placeholderStudent.removeMentor(this);
      }
    }
  }


  public String toString()
  {
    return super.toString() + "["+
            "name" + ":" + getName()+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "student = "+(getStudent()!=null?Integer.toHexString(System.identityHashCode(getStudent())):"null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example.two;
import java.util.*;
import example.one.*;
import example.three.*;

// line 11 "../../ClassTemplateTest_Import.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Student Attributes
  private String number;

  //Student Associations
  private List<Mentor> mentors;
  private List<Course> courses;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student(String aNumber, Mentor... allMentors)
  {
    number = aNumber;
    mentors = new ArrayList<Mentor>();
    boolean didAddMentors = setMentors(allMentors);
    if (!didAddMentors)
    {
      throw new RuntimeException("Unable to create Student, must have at least 1 mentors. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    courses = new ArrayList<Course>();
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setNumber(String aNumber)
  {
    boolean wasSet = false;
    number = aNumber;
    wasSet = true;
    return wasSet;
  }

  public String getNumber()
  {
    return number;
  }
  /* Code from template association_GetMany */
  public Mentor getMentor(int index)
  {
    Mentor aMentor = mentors.get(index);
    return aMentor;
  }

  public List<Mentor> getMentors()
  {
    List<Mentor> newMentors = Collections.unmodifiableList(mentors);
    return newMentors;
  }

  public int numberOfMentors()
  {
    int number = mentors.size();
    return number;
  }

  public boolean hasMentors()
  {
    boolean has = mentors.size() > 0;
    return has;
  }

  public int indexOfMentor(Mentor aMentor)
  {
    int index = mentors.indexOf(aMentor);
    return index;
  }
  /* Code from template association_GetMany */
  public Course getCourse(int index)
  {
    Course aCourse = courses.get(index);
    return aCourse;
  }

  public List<Course> getCourses()
  {
    List<Course> newCourses = Collections.unmodifiableList(courses);
    return newCourses;
  }

  public int numberOfCourses()
  {
    int number = courses.size();
    return number;
  }

  public boolean hasCourses()
  {
    boolean has = courses.size() > 0;
    return has;
  }

  public int indexOfCourse(Course aCourse)
  {
    int index = courses.indexOf(aCourse);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfMentors()
  {
    return 1;
  }
  /* Code from template association_AddMNToOptionalOne */
  public boolean addMentor(Mentor aMentor)
  {
    boolean wasAdded = false;
    if (mentors.contains(aMentor)) { return false; }
    Student existingStudent = aMentor.getStudent();
    if (existingStudent != null && existingStudent.numberOfMentors() <= minimumNumberOfMentors())
    {
      return wasAdded;
    }
    else if (existingStudent != null)
    {
      existingStudent.mentors.remove(aMentor);
    }
    mentors.add(aMentor);
    setStudent(aMentor,this);
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeMentor(Mentor aMentor)
  {
    boolean wasRemoved = false;
    if (mentors.contains(aMentor) && numberOfMentors() > minimumNumberOfMentors())
    {
      mentors.remove(aMentor);
      setStudent(aMentor,null);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_SetMNToOptionalOne */
  public boolean setMentors(Mentor... newMentors)
  {
    boolean wasSet = false;
    if (newMentors.length < minimumNumberOfMentors())
    {
      return wasSet;
    }

    ArrayList<Mentor> checkNewMentors = new ArrayList<Mentor>();
    HashMap<Student,Integer> studentToNewMentors = new HashMap<Student,Integer>();
    for (Mentor aMentor : newMentors)
    {
      if (checkNewMentors.contains(aMentor))
      {
        return wasSet;
      }
      else if (aMentor.getStudent() != null && !this.equals(aMentor.getStudent()))
      {
        Student existingStudent = aMentor.getStudent();
        if (!studentToNewMentors.containsKey(existingStudent))
        {
          studentToNewMentors.put(existingStudent, Integer.valueOf(existingStudent.numberOfMentors()));
        }
        Integer currentCount = studentToNewMentors.get(existingStudent);
        int nextCount = currentCount - 1;
        if (nextCount < 1)
        {
          return wasSet;
        }
        studentToNewMentors.put(existingStudent, Integer.valueOf(nextCount));
      }
      checkNewMentors.add(aMentor);
    }

    mentors.removeAll(checkNewMentors);

    for (Mentor orphan : mentors)
    {
      setStudent(orphan, null);
    }
    mentors.clear();
    for (Mentor aMentor : newMentors)
    {
      if (aMentor.getStudent() != null)
      {
        aMentor.getStudent().mentors.remove(aMentor);
      }
      setStudent(aMentor, this);
      mentors.add(aMentor);
    }
    wasSet = true;
    return wasSet;
  }
  /* Code from template association_GetPrivate */
  private void setStudent(Mentor aMentor, Student aStudent)
  {
    try
    {
      java.lang.reflect.Field mentorField = aMentor.getClass().getDeclaredField("student");
      mentorField.setAccessible(true);
      mentorField.set(aMentor, aStudent);
    }
    catch (Exception e)
    {
      throw new RuntimeException("Issue internally setting aStudent to aMentor", e);
    }
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addMentorAt(Mentor aMentor, int index)
  {  
    boolean wasAdded = false;
    if(addMentor(aMentor))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMentors()) { index = numberOfMentors() - 1; }
      mentors.remove(aMentor);
      mentors.add(index, aMentor);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveMentorAt(Mentor aMentor, int index)
  {
    boolean wasAdded = false;
    if(mentors.contains(aMentor))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMentors()) { index = numberOfMentors() - 1; }
      mentors.remove(aMentor);
      mentors.add(index, aMentor);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addMentorAt(aMentor, index);
    }
    return wasAdded;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfCourses()
  {
    return 0;
  }
  /* Code from template association_AddManyToManyMethod */
  public boolean addCourse(Course aCourse)
  {
    boolean wasAdded = false;
    if (courses.contains(aCourse)) { return false; }
    courses.add(aCourse);
    if (aCourse.indexOfStudent(this) != -1)
    {
      wasAdded = true;
    }
    else
    {
      wasAdded = aCourse.addStudent(this);
      if (!wasAdded)
      {
        courses.remove(aCourse);
      }
    }
    return wasAdded;
  }
  /* Code from template association_RemoveMany */
  public boolean removeCourse(Course aCourse)
  {
    boolean wasRemoved = false;
    if (!courses.contains(aCourse))
    {
      return wasRemoved;
    }

    int oldIndex = courses.indexOf(aCourse);
    courses.remove(oldIndex);
    if (aCourse.indexOfStudent(this) == -1)
    {
      wasRemoved = true;
    }
    else
    {
      wasRemoved = aCourse.removeStudent(this);
      if (!wasRemoved)
      {
        courses.add(oldIndex,aCourse);
      }
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addCourseAt(Course aCourse, int index)
  {  
    boolean wasAdded = false;
    if(addCourse(aCourse))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfCourses()) { index = numberOfCourses() - 1; }
      courses.remove(aCourse);
      courses.add(index, aCourse);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveCourseAt(Course aCourse, int index)
  {
    boolean wasAdded = false;
    if(courses.contains(aCourse))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfCourses()) { index = numberOfCourses() - 1; }
      courses.remove(aCourse);
      courses.add(index, aCourse);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addCourseAt(aCourse, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(Mentor aMentor : mentors)
    {
      setStudent(aMentor,null);
    }
    mentors.clear();
    ArrayList<Course> copyOfCourses = new ArrayList<Course>(courses);
    courses.clear();
    for(Course aCourse : copyOfCourses)
    {
      aCourse.removeStudent(this);
    }
  }


  public String toString()
  {
    return super.toString() + "["+
            "number" + ":" + getNumber()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example.three;
import java.util.*;
import example.two.*;

// line 18 "../../ClassTemplateTest_Import.ump"
public class Course
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Course Associations
  private List<Student> students;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Course()
  {
    students = new ArrayList<Student>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public Student getStudent(int index)
  {
    Student aStudent = students.get(index);
    return aStudent;
  }

  public List<Student> getStudents()
  {
    List<Student> newStudents = Collections.unmodifiableList(students);
    return newStudents;
  }

  public int numberOfStudents()
  {
    int number = students.size();
    return number;
  }

  public boolean hasStudents()
  {
    boolean has = students.size() > 0;
    return has;
  }

  public int indexOfStudent(Student aStudent)
  {
    int index = students.indexOf(aStudent);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfStudents()
  {
    return 0;
  }
  /* Code from template association_AddManyToManyMethod */
  public boolean addStudent(Student aStudent)
  {
    boolean wasAdded = false;
    if (students.contains(aStudent)) { return false; }
    students.add(aStudent);
    if (aStudent.indexOfCourse(this) != -1)
    {
      wasAdded = true;
    }
    else
    {
      wasAdded = aStudent.addCourse(this);
      if (!wasAdded)
      {
        students.remove(aStudent);
      }
    }
    return wasAdded;
  }
  /* Code from template association_RemoveMany */
  public boolean removeStudent(Student aStudent)
  {
    boolean wasRemoved = false;
    if (!students.contains(aStudent))
    {
      return wasRemoved;
    }

    int oldIndex = students.indexOf(aStudent);
    students.remove(oldIndex);
    if (aStudent.indexOfCourse(this) == -1)
    {
      wasRemoved = true;
    }
    else
    {
      wasRemoved = aStudent.removeCourse(this);
      if (!wasRemoved)
      {
        students.add(oldIndex,aStudent);
      }
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addStudentAt(Student aStudent, int index)
  {  
    boolean wasAdded = false;
    if(addStudent(aStudent))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfStudents()) { index = numberOfStudents() - 1; }
      students.remove(aStudent);
      students.add(index, aStudent);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveStudentAt(Student aStudent, int index)
  {
    boolean wasAdded = false;
    if(students.contains(aStudent))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfStudents()) { index = numberOfStudents() - 1; }
      students.remove(aStudent);
      students.add(index, aStudent);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addStudentAt(aStudent, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    ArrayList<Student> copyOfStudents = new ArrayList<Student>(students);
    students.clear();
    for(Student aStudent : copyOfStudents)
    {
      aStudent.removeCourse(this);
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
  public String foo(int a){
    // line 16 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
    System.out.println("Starting foo with argument: " + a);
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {      
      // line 20 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 0;
    }
    else if(a == 1) {      
      // line 20 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return -1;
    }
    else {      
      // line 20 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 4;
    }

    for(int i = 0; i < a; i++) {
      // TODO: call foo()
      if(i == a/4) {        
        // line 20 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
        System.out.println("Returning from foo!");
        // END OF UMPLE AFTER INJECTION
        return a;
      }
    }    
    // line 20 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
    System.out.println("Returning from foo!");
    // END OF UMPLE AFTER INJECTION
    return 4;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_Methods.ump"
public class CodeTranslator
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public CodeTranslator()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 6 "../ClassTemplateTest_Methods.ump"
  public String translate(String id, Attribute attribute){
    return "1";
  }

  // line 9 "../ClassTemplateTest_Methods.ump"
  public String translate(String id, AssociationVariable associationVariable){
    return "1";
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 7 "ClassTemplateTest_StateMachineImplementsInterface.ump"
public class FileLogger implements Logger
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //FileLogger Attributes
  private String fileName;

  //FileLogger State Machines
  public enum Status { disconnected, connected }
  private Status status;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public FileLogger(String aFileName)
  {
    fileName = aFileName;
    setStatus(Status.disconnected);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public String getStatusFullName()
  {
    String answer = status.toString();
    return answer;
  }

  public Status getStatus()
  {
    return status;
  }

  @Override
  public boolean connect()
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case disconnected:
        setStatus(Status.connected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  @Override
  public boolean disconnect()
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case connected:
        setStatus(Status.disconnected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  @Override
  public boolean write(String data)
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case connected:
        setStatus(Status.connected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  private void setStatus(Status aStatus)
  {
    status = aStatus;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_AttributeComments.ump"
public class Student
{

  //------------------------
  // STATIC VARIABLES
  //------------------------


  /**
   * Comment for a const attribute
   */
  public static final String a = "";

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Student Attributes

  /**
   * Comment for an internal attribute
   */
  private String b;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student(String aB)
  {
    b = aB;
  }

  //------------------------
  // INTERFACE
  //------------------------

  /**
   * Comment for a derived attribute
   */

  public int getC()
  {
    return 1+1;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "c" + ":" + getC()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_CodeInjectionsBasicOnOneLine.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  // line 3 "ClassTemplateTest_CodeInjectionsBasicOnOneLine.ump"
  public String foo(int a){
    // line 16 "ClassTemplateTest_CodeInjectionsBasicOnOneLine.ump"
    System.out.println("Starting foo with argument: " + a);
    // END OF UMPLE BEFORE INJECTION
    if(a < 0) {      
      // line 18 "ClassTemplateTest_CodeInjectionsBasicOnOneLine.ump"
      System.out.println("Returning from foo!");
      // END OF UMPLE AFTER INJECTION
      return 0;
    }

    for(int i = 0; i < a; i++) {
      if(i == a/4) {        
        // line 18 "ClassTemplateTest_CodeInjectionsBasicOnOneLine.ump"
        System.out.println("Returning from foo!");
        // END OF UMPLE AFTER INJECTION
        return a;
      }
    }    
    // line 18 "ClassTemplateTest_CodeInjectionsBasicOnOneLine.ump"
    System.out.println("Returning from foo!");
    // END OF UMPLE AFTER INJECTION
    return 4;

  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 7 "ClassTemplateTest_StateMachineImplementsPartialInterface.ump"
public class FileLogger implements Logger
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //FileLogger Attributes
  private String fileName;

  //FileLogger State Machines
  public enum Status { disconnected, connected }
  private Status status;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public FileLogger(String aFileName)
  {
    fileName = aFileName;
    setStatus(Status.disconnected);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public String getStatusFullName()
  {
    String answer = status.toString();
    return answer;
  }

  public Status getStatus()
  {
    return status;
  }

  @Override
  public boolean connect()
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case disconnected:
        setStatus(Status.connected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  @Override
  public boolean disconnect()
  {
    boolean wasEventProcessed = false;
    
    Status aStatus = status;
    switch (aStatus)
    {
      case connected:
        setStatus(Status.disconnected);
        wasEventProcessed = true;
        break;
      default:
        // Other states do respond to this event
    }

    return wasEventProcessed;
  }

  private void setStatus(Status aStatus)
  {
    status = aStatus;
  }

  public void delete()
  {}

  @Override
  public boolean write(String data){
          return false;
  }


  public String toString()
  {
    return super.toString() + "["+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 9 "../ClassTemplateTest_ImplementedMethods.ump"
public class CodeTranslator implements ICodeTranslator
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public CodeTranslator()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  @Override
  public String translate(String id, Attribute attribute){
          return "";
  }

  @Override
  public String translate(String id, AssociationVariable associationVariable){
          return "";
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 5 "ClassTemplateTest_VoidImplementedMethod.ump"
public class ClientConsole implements ChatIF
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public ClientConsole()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

  @Override
  public void display(){
          return ;
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;
import java.sql.Date;
import java.sql.Time;
import java.util.*;

// line 4 "../ClassTemplateTest_Attributes.ump"
public class Mentor
{

  //------------------------
  // STATIC VARIABLES
  //------------------------

  public static final int MAX = 100;
  public static final int MIN = -99;
  public static final String HELLO = "Hello";
  private static int nextX = 1;
  private static Map<String, Mentor> mentorsById = new HashMap<String, Mentor>();

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Mentor Attributes
  private String str;
  private String str2;
  private String someName;
  private double lDoub;
  private boolean lBool;
  private String name;
  private Date d;
  private Time t;
  private int i;
  private String id;
  private String p;
  private String q;
  private String r;
  private String s;
  private Date tt;
  private Time u;
  private Date v;
  private Time w;

  //Autounique Attributes
  private int x;

  //Helper Variables
  private boolean canSetStr2;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor(String aStr, Date aD, int aI, String aId)
  {
    str = aStr;
    canSetStr2 = true;
    someName = null;
    lDoub = 0;
    lBool = false;
    name = "Johannes";
    d = aD;
    t = new Time();
    i = aI;
    resetP();
    q = "chicken";
    resetR();
    s = "123";
    tt = Date.valueOf("1978-12-25");
    u = Time.valueOf("12:13:14");
    resetV();
    resetW();
    x = nextX++;
    if (!setId(aId))
    {
      throw new RuntimeException("Cannot create due to duplicate id. See https://manual.umple.org?RE003ViolationofUniqueness.html");
    }
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template attribute_SetImmutable */
  public boolean setStr2(String aStr2)
  {
    boolean wasSet = false;
    if (!canSetStr2) { return false; }
    canSetStr2 = false;
    str2 = aStr2;
    wasSet = true;
    return wasSet;
  }

  public boolean setSomeName(String aSomeName)
  {
    boolean wasSet = false;
    someName = aSomeName;
    wasSet = true;
    return wasSet;
  }

  public boolean setLDoub(double aLDoub)
  {
    boolean wasSet = false;
    lDoub = aLDoub;
    wasSet = true;
    return wasSet;
  }

  public boolean setLBool(boolean aLBool)
  {
    boolean wasSet = false;
    lBool = aLBool;
    wasSet = true;
    return wasSet;
  }

  public boolean setName(String aName)
  {
    boolean wasSet = false;
    name = aName;
    wasSet = true;
    return wasSet;
  }

  public boolean setD(Date aD)
  {
    boolean wasSet = false;
    d = aD;
    wasSet = true;
    return wasSet;
  }

  public boolean setI(int aI)
  {
    boolean wasSet = false;
    i = aI;
    wasSet = true;
    return wasSet;
  }

  public boolean setId(String aId)
  {
    boolean wasSet = false;
    String anOldId = getId();
    if (anOldId != null && anOldId.equals(aId)) {
      return true;
    }
    if (hasWithId(aId)) {
      return wasSet;
    }
    id = aId;
    wasSet = true;
    if (anOldId != null) {
      mentorsById.remove(anOldId);
    }
    mentorsById.put(aId, this);
    return wasSet;
  }
  /* Code from template attribute_SetDefaulted */
  public boolean setP(String aP)
  {
    boolean wasSet = false;
    p = aP;
    wasSet = true;
    return wasSet;
  }

  public boolean resetP()
  {
    boolean wasReset = false;
    p = getDefaultP();
    wasReset = true;
    return wasReset;
  }

  public boolean setQ(String aQ)
  {
    boolean wasSet = false;
    q = aQ;
    wasSet = true;
    return wasSet;
  }
  /* Code from template attribute_SetDefaulted */
  public boolean setR(String aR)
  {
    boolean wasSet = false;
    r = aR;
    wasSet = true;
    return wasSet;
  }

  public boolean resetR()
  {
    boolean wasReset = false;
    r = getDefaultR();
    wasReset = true;
    return wasReset;
  }

  public boolean setTt(Date aTt)
  {
    boolean wasSet = false;
    tt = aTt;
    wasSet = true;
    return wasSet;
  }

  public boolean setU(Time aU)
  {
    boolean wasSet = false;
    u = aU;
    wasSet = true;
    return wasSet;
  }
  /* Code from template attribute_SetDefaulted */
  public boolean setV(Date aV)
  {
    boolean wasSet = false;
    v = aV;
    wasSet = true;
    return wasSet;
  }

  public boolean resetV()
  {
    boolean wasReset = false;
    v = getDefaultV();
    wasReset = true;
    return wasReset;
  }
  /* Code from template attribute_SetDefaulted */
  public boolean setW(Time aW)
  {
    boolean wasSet = false;
    w = aW;
    wasSet = true;
    return wasSet;
  }

  public boolean resetW()
  {
    boolean wasReset = false;
    w = getDefaultW();
    wasReset = true;
    return wasReset;
  }

  public String getStr()
  {
    return str;
  }

  public String getStr2()
  {
    return str2;
  }

  public String getSomeName()
  {
    return someName;
  }

  public double getLDoub()
  {
    return lDoub;
  }

  public boolean getLBool()
  {
    return lBool;
  }

  public String getName()
  {
    return name;
  }

  public Date getD()
  {
    return d;
  }

  public int getI()
  {
    return i;
  }

  public int getDerivedTwiceI()
  {
    return i*2;
  }

  public String getId()
  {
    return id;
  }
  /* Code from template attribute_GetUnique */
  public static Mentor getWithId(String aId)
  {
    return mentorsById.get(aId);
  }
  /* Code from template attribute_HasUnique */
  public static boolean hasWithId(String aId)
  {
    return getWithId(aId) != null;
  }

  public String getP()
  {
    return p;
  }
  /* Code from template attribute_GetDefaulted */
  public String getDefaultP()
  {
    return "robot";
  }

  public String getQ()
  {
    return q;
  }

  public String getR()
  {
    return r;
  }
  /* Code from template attribute_GetDefaulted */
  public String getDefaultR()
  {
    return "";
  }

  public String getS()
  {
    return s;
  }

  public Date getTt()
  {
    return tt;
  }

  public Time getU()
  {
    return u;
  }

  public Date getV()
  {
    return v;
  }
  /* Code from template attribute_GetDefaulted */
  public Date getDefaultV()
  {
    return Date.valueOf("1978-12-26");
  }

  public Time getW()
  {
    return w;
  }
  /* Code from template attribute_GetDefaulted */
  public Time getDefaultW()
  {
    return Time.valueOf("12:59:59");
  }

  public int getX()
  {
    return x;
  }
  /* Code from template attribute_IsBoolean */
  public boolean isLBool()
  {
    return lBool;
  }

  public void delete()
  {
    mentorsById.remove(getId());
  }


  public String toString()
  {
    return super.toString() + "["+
            "x" + ":" + getX()+ "," +
            "str" + ":" + getStr()+ "," +
            "str2" + ":" + getStr2()+ "," +
            "someName" + ":" + getSomeName()+ "," +
            "lDoub" + ":" + getLDoub()+ "," +
            "lBool" + ":" + getLBool()+ "," +
            "name" + ":" + getName()+ "," +
            "i" + ":" + getI()+ "," +
            "derivedTwiceI" + ":" + getDerivedTwiceI()+ "," +
            "id" + ":" + getId()+ "," +
            "p" + ":" + getP()+ "," +
            "q" + ":" + getQ()+ "," +
            "r" + ":" + getR()+ "," +
            "s" + ":" + getS()+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "d" + "=" + (getD() != null ? !getD().equals(this)  ? getD().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "tt" + "=" + (getTt() != null ? !getTt().equals(this)  ? getTt().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "u" + "=" + (getU() != null ? !getU().equals(this)  ? getU().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "v" + "=" + (getV() != null ? !getV().equals(this)  ? getV().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "w" + "=" + (getW() != null ? !getW().equals(this)  ? getW().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 1 "ClassTemplateTest_AbstractClassAvoidingInstantiation.ump"
public class Teacher
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Teacher Associations
  private List<Person> myStudents;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Teacher()
  {
    myStudents = new ArrayList<Person>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public Person getMyStudent(int index)
  {
    Person aMyStudent = myStudents.get(index);
    return aMyStudent;
  }

  public List<Person> getMyStudents()
  {
    List<Person> newMyStudents = Collections.unmodifiableList(myStudents);
    return newMyStudents;
  }

  public int numberOfMyStudents()
  {
    int number = myStudents.size();
    return number;
  }

  public boolean hasMyStudents()
  {
    boolean has = myStudents.size() > 0;
    return has;
  }

  public int indexOfMyStudent(Person aMyStudent)
  {
    int index = myStudents.indexOf(aMyStudent);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfMyStudents()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */


  public boolean addMyStudent(Person aMyStudent)
  {
    boolean wasAdded = false;
    if (myStudents.contains(aMyStudent)) { return false; }
    Teacher existingTeacher = aMyStudent.getTeacher();
    boolean isNewTeacher = existingTeacher != null && !this.equals(existingTeacher);
    if (isNewTeacher)
    {
      aMyStudent.setTeacher(this);
    }
    else
    {
      myStudents.add(aMyStudent);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeMyStudent(Person aMyStudent)
  {
    boolean wasRemoved = false;
    //Unable to remove aMyStudent, as it must always have a teacher
    if (!this.equals(aMyStudent.getTeacher()))
    {
      myStudents.remove(aMyStudent);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addMyStudentAt(Person aMyStudent, int index)
  {  
    boolean wasAdded = false;
    if(addMyStudent(aMyStudent))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMyStudents()) { index = numberOfMyStudents() - 1; }
      myStudents.remove(aMyStudent);
      myStudents.add(index, aMyStudent);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveMyStudentAt(Person aMyStudent, int index)
  {
    boolean wasAdded = false;
    if(myStudents.contains(aMyStudent))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMyStudents()) { index = numberOfMyStudents() - 1; }
      myStudents.remove(aMyStudent);
      myStudents.add(index, aMyStudent);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addMyStudentAt(aMyStudent, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=myStudents.size(); i > 0; i--)
    {
      Person aMyStudent = myStudents.get(i - 1);
      aMyStudent.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 1 "ClassTemplateTest_MultivaluedAttributesAssignment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Attributes
  private List<String> someStrings;
  private List<Integer> numbers;
  private List<Token> objects;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {
    someStrings = new ArrayList<String>(); 
    someStrings.add("a"); 
    someStrings.add("b"); 
    someStrings.add("c");
    numbers = new ArrayList<Integer>(); 
    numbers.add(1); 
    numbers.add(2); 
    numbers.add(3); 
    numbers.add(10);
    objects = new ArrayList<Token>(); 
    objects.add(new Token("first")); 
    objects.add(new Token("second"));
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template attribute_SetMany */
  public boolean addSomeString(String aSomeString)
  {
    boolean wasAdded = false;
    wasAdded = someStrings.add(aSomeString);
    return wasAdded;
  }

  public boolean removeSomeString(String aSomeString)
  {
    boolean wasRemoved = false;
    wasRemoved = someStrings.remove(aSomeString);
    return wasRemoved;
  }
  /* Code from template attribute_SetMany */
  public boolean addNumber(Integer aNumber)
  {
    boolean wasAdded = false;
    wasAdded = numbers.add(aNumber);
    return wasAdded;
  }

  public boolean removeNumber(Integer aNumber)
  {
    boolean wasRemoved = false;
    wasRemoved = numbers.remove(aNumber);
    return wasRemoved;
  }
  /* Code from template attribute_SetMany */
  public boolean addObject(Token aObject)
  {
    boolean wasAdded = false;
    wasAdded = objects.add(aObject);
    return wasAdded;
  }

  public boolean removeObject(Token aObject)
  {
    boolean wasRemoved = false;
    wasRemoved = objects.remove(aObject);
    return wasRemoved;
  }
  /* Code from template attribute_GetMany */
  public String getSomeString(int index)
  {
    String aSomeString = someStrings.get(index);
    return aSomeString;
  }

  public String[] getSomeStrings()
  {
    String[] newSomeStrings = someStrings.toArray(new String[someStrings.size()]);
    return newSomeStrings;
  }

  public int numberOfSomeStrings()
  {
    int number = someStrings.size();
    return number;
  }

  public boolean hasSomeStrings()
  {
    boolean has = someStrings.size() > 0;
    return has;
  }

  public int indexOfSomeString(String aSomeString)
  {
    int index = someStrings.indexOf(aSomeString);
    return index;
  }
  /* Code from template attribute_GetMany */
  public Integer getNumber(int index)
  {
    Integer aNumber = numbers.get(index);
    return aNumber;
  }

  public Integer[] getNumbers()
  {
    Integer[] newNumbers = numbers.toArray(new Integer[numbers.size()]);
    return newNumbers;
  }

  public int numberOfNumbers()
  {
    int number = numbers.size();
    return number;
  }

  public boolean hasNumbers()
  {
    boolean has = numbers.size() > 0;
    return has;
  }

  public int indexOfNumber(Integer aNumber)
  {
    int index = numbers.indexOf(aNumber);
    return index;
  }
  /* Code from template attribute_GetMany */
  public Token getObject(int index)
  {
    Token aObject = objects.get(index);
    return aObject;
  }

  public Token[] getObjects()
  {
    Token[] newObjects = objects.toArray(new Token[objects.size()]);
    return newObjects;
  }

  public int numberOfObjects()
  {
    int number = objects.size();
    return number;
  }

  public boolean hasObjects()
  {
    boolean has = objects.size() > 0;
    return has;
  }

  public int indexOfObject(Token aObject)
  {
    int index = objects.indexOf(aObject);
    return index;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

/**
 * This is a student
 */
// line 4 "../ClassTemplateTest_Comment.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 1 "AssociationMultilineComment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Associations
  private List<Bar> bars;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {
    bars = new ArrayList<Bar>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public Bar getBar(int index)
  {
    Bar aBar = bars.get(index);
    return aBar;
  }

  /**
   * I am a multiline comment above an association.
   */
  public List<Bar> getBars()
  {
    List<Bar> newBars = Collections.unmodifiableList(bars);
    return newBars;
  }

  public int numberOfBars()
  {
    int number = bars.size();
    return number;
  }

  public boolean hasBars()
  {
    boolean has = bars.size() > 0;
    return has;
  }

  public int indexOfBar(Bar aBar)
  {
    int index = bars.indexOf(aBar);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfBars()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Bar addBar()
  {
    return new Bar(this);
  }

  public boolean addBar(Bar aBar)
  {
    boolean wasAdded = false;
    if (bars.contains(aBar)) { return false; }
    Foo existingFoo = aBar.getFoo();
    boolean isNewFoo = existingFoo != null && !this.equals(existingFoo);
    if (isNewFoo)
    {
      aBar.setFoo(this);
    }
    else
    {
      bars.add(aBar);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeBar(Bar aBar)
  {
    boolean wasRemoved = false;
    //Unable to remove aBar, as it must always have a foo
    if (!this.equals(aBar.getFoo()))
    {
      bars.remove(aBar);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addBarAt(Bar aBar, int index)
  {  
    boolean wasAdded = false;
    if(addBar(aBar))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBars()) { index = numberOfBars() - 1; }
      bars.remove(aBar);
      bars.add(index, aBar);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveBarAt(Bar aBar, int index)
  {
    boolean wasAdded = false;
    if(bars.contains(aBar))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBars()) { index = numberOfBars() - 1; }
      bars.remove(aBar);
      bars.add(index, aBar);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addBarAt(aBar, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=bars.size(); i > 0; i--)
    {
      Bar aBar = bars.get(i - 1);
      aBar.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_EmptyStringAttr.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Student Attributes
  private String grade;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {
    grade = "";
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setGrade(String aGrade)
  {
    boolean wasSet = false;
    grade = aGrade;
    wasSet = true;
    return wasSet;
  }

  public String getGrade()
  {
    return grade;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "grade" + ":" + getGrade()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_AssociationAttributes.ump"
public class Token
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Token Attributes
  private Position p;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Token(Position aP)
  {
    p = aP;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setP(Position aP)
  {
    boolean wasSet = false;
    p = aP;
    wasSet = true;
    return wasSet;
  }

  public Position getP()
  {
    return p;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "p" + "=" + (getP() != null ? !getP().equals(this)  ? getP().toString().replaceAll("  ","    ") : "this" : "null");
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

/**
 * This is a student
 * Multiple comments
 * on several lines
 */
// line 6 "../ClassTemplateTest_MultiComment.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_AbstractClass.ump"
public abstract class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



/**
 * I am a class comment.
 * 
 * Notice how there are 4 empty lines below me.
 * 
 * 
 * 
 * 
 * And 2 below me.
 * 
 * 
 * These lines should come out as we see here.
 * Comments such as these are often used to improve readability through whitespace clarity.
 */
// line 15 "ClassCommentWithEmptyLines.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "AttributeMultilineComment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Attributes
  private String name;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo(String aName)
  {
    name = aName;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setName(String aName)
  {
    boolean wasSet = false;
    name = aName;
    wasSet = true;
    return wasSet;
  }

  /**
   * I am a multiline comment above an attribute.
   */
  public String getName()
  {
    return name;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "name" + ":" + getName()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;
import java.lang.Thread;

// line 1 "ClassTemplateTest_QueuedMethod.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Helper Variables

  protected enum QueuedMethod { method1_M }  QueuedMethodThread queuedMethodThread;


  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {
    queuedMethodThread = new QueuedMethodThread();
  }

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {
    queuedMethodThread.delete();
  }

  public void method1 ()
  {
    queuedMethodThread.putCallTo(queuedMethodThread.new QueuedMethodMessage(QueuedMethod.method1_M, null));
  }

  // line 5 "ClassTemplateTest_QueuedMethod.ump"
  public void _method1(){
    //implementation
  }

  private class QueuedMethodThread implements Runnable
  {

    QueuedMethodMessageQueue methodQueue;
    Thread methodRemoval;
    
    public QueuedMethodThread()
    {
      methodQueue = new QueuedMethodMessageQueue();
      methodRemoval = new Thread(this);
      //start the thread for queued methods of Foo
      methodRemoval.start();   
    }

    protected class QueuedMethodMessage
    {
      QueuedMethod type;
      
      //QueuedMethodMessage parameters
      Vector<Object> param;
      
      public QueuedMethodMessage(QueuedMethod t, Vector<Object> p)
      {
        type = t; 
        param = p;
      }

      @Override
      public String toString()
      {
        return type + "," + param;
      }
    }
  
    protected class QueuedMethodMessageQueue {
      Queue<QueuedMethodMessage> messages = new LinkedList<QueuedMethodMessage>();
      
      public synchronized void put(QueuedMethodMessage m)
      {
        messages.add(m); 
        notify();
      }

      public synchronized QueuedMethodMessage getNext()
      {
        try {
          while (messages.isEmpty()) 
          {
            wait();
          }
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          return null;
        }

        //The element to be removed
        QueuedMethodMessage m = messages.remove(); 
        return (m);
      }
    }

    @Override
    public void run ()
    {
      boolean status=false;
      while (true) 
      {
        QueuedMethodMessage qmm = methodQueue.getNext();
        if(qmm == null)  return;
        switch(qmm.type)
        {
          case method1_M:
            _method1();
            break;
          default:
        }
      }
    }
    public void putCallTo(QueuedMethodMessage message)
    {
      methodQueue.put(message);
    }

    public void delete()
    {
       methodRemoval.interrupt();
    }
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "ClassTemplateTest_NoNamespace.ump"
public class Token
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Token()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "MultipleAttributeComments.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Attributes
  private String testAttribute1;
  private String testAttribute2;
  private String testAttribute3;
  private String testAttribute4;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo(String aTestAttribute1, String aTestAttribute2, String aTestAttribute3, String aTestAttribute4)
  {
    testAttribute1 = aTestAttribute1;
    testAttribute2 = aTestAttribute2;
    testAttribute3 = aTestAttribute3;
    testAttribute4 = aTestAttribute4;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setTestAttribute1(String aTestAttribute1)
  {
    boolean wasSet = false;
    testAttribute1 = aTestAttribute1;
    wasSet = true;
    return wasSet;
  }

  public boolean setTestAttribute2(String aTestAttribute2)
  {
    boolean wasSet = false;
    testAttribute2 = aTestAttribute2;
    wasSet = true;
    return wasSet;
  }

  public boolean setTestAttribute3(String aTestAttribute3)
  {
    boolean wasSet = false;
    testAttribute3 = aTestAttribute3;
    wasSet = true;
    return wasSet;
  }

  public boolean setTestAttribute4(String aTestAttribute4)
  {
    boolean wasSet = false;
    testAttribute4 = aTestAttribute4;
    wasSet = true;
    return wasSet;
  }

  /**
   * Inline comment above attribute.
   */
  public String getTestAttribute1()
  {
    return testAttribute1;
  }

  /**
   * Multiple inline comments
   * above attribute.
   */
  public String getTestAttribute2()
  {
    return testAttribute2;
  }

  /**
   * Multiline comment above attribute.
   */
  public String getTestAttribute3()
  {
    return testAttribute3;
  }

  /**
   * Multiple multiline comments
   * above attribute.
   */
  public String getTestAttribute4()
  {
    return testAttribute4;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "testAttribute1" + ":" + getTestAttribute1()+ "," +
            "testAttribute2" + ":" + getTestAttribute2()+ "," +
            "testAttribute3" + ":" + getTestAttribute3()+ "," +
            "testAttribute4" + ":" + getTestAttribute4()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 8 "../ClassTemplateTest_IsA.ump"
public class SubMentor extends Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public SubMentor(String aName)
  {
    super(aName);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {
    super.delete();
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 13 "../ClassTemplateTest_IsA.ump"
public class SubMentor2 extends Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //SubMentor2 Attributes
  private String subName;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public SubMentor2(String aName, String aSubName)
  {
    super(aName);
    subName = aSubName;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setSubName(String aSubName)
  {
    boolean wasSet = false;
    subName = aSubName;
    wasSet = true;
    return wasSet;
  }

  public String getSubName()
  {
    return subName;
  }

  public void delete()
  {
    super.delete();
  }


  public String toString()
  {
    return super.toString() + "["+
            "subName" + ":" + getSubName()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;
import java.util.*;

// line 3 "../ClassTemplateTest_ListAttributes.ump"
public class Token
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Token Attributes
  private List<Position> positions;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Token()
  {
    positions = new ArrayList<Position>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template attribute_SetMany */
  public boolean addPosition(Position aPosition)
  {
    boolean wasAdded = false;
    wasAdded = positions.add(aPosition);
    return wasAdded;
  }

  public boolean removePosition(Position aPosition)
  {
    boolean wasRemoved = false;
    wasRemoved = positions.remove(aPosition);
    return wasRemoved;
  }
  /* Code from template attribute_GetMany */
  public Position getPosition(int index)
  {
    Position aPosition = positions.get(index);
    return aPosition;
  }

  public Position[] getPositions()
  {
    Position[] newPositions = positions.toArray(new Position[positions.size()]);
    return newPositions;
  }

  public int numberOfPositions()
  {
    int number = positions.size();
    return number;
  }

  public boolean hasPositions()
  {
    boolean has = positions.size() > 0;
    return has;
  }

  public int indexOfPosition(Position aPosition)
  {
    int index = positions.indexOf(aPosition);
    return index;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "MethodCommentWithEmptyLines.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}


  /**
   * I am a method comment.
   * 
   * Notice how there are 4 empty lines below me.
   * 
   * 
   * 
   * 
   * And 2 below me.
   * 
   * 
   * These lines should come out as we see here.
   * Comments such as these are often used to improve readability through whitespace clarity.
   */
  // line 19 "MethodCommentWithEmptyLines.ump"
  public void testMethod(){
    // I am a test method.
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

// line 3 "../ClassTemplateTest_EmptyClass.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 16 "ClassTemplateTest_AbstractClassInheritance.ump"
public class Teacher extends Person
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Teacher Attributes
  private String position;

  //Teacher Associations
  private List<Student> students;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Teacher(String aName, int aAge, String aPosition)
  {
    super(aName, aAge);
    position = aPosition;
    students = new ArrayList<Student>();
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setPosition(String aPosition)
  {
    boolean wasSet = false;
    position = aPosition;
    wasSet = true;
    return wasSet;
  }

  public String getPosition()
  {
    return position;
  }
  /* Code from template association_GetMany */
  public Student getStudent(int index)
  {
    Student aStudent = students.get(index);
    return aStudent;
  }

  public List<Student> getStudents()
  {
    List<Student> newStudents = Collections.unmodifiableList(students);
    return newStudents;
  }

  public int numberOfStudents()
  {
    int number = students.size();
    return number;
  }

  public boolean hasStudents()
  {
    boolean has = students.size() > 0;
    return has;
  }

  public int indexOfStudent(Student aStudent)
  {
    int index = students.indexOf(aStudent);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfStudents()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Student addStudent(String aName, int aAge, int aStudentID)
  {
    return new Student(aName, aAge, aStudentID, this);
  }

  public boolean addStudent(Student aStudent)
  {
    boolean wasAdded = false;
    if (students.contains(aStudent)) { return false; }
    Teacher existingTeacher = aStudent.getTeacher();
    boolean isNewTeacher = existingTeacher != null && !this.equals(existingTeacher);
    if (isNewTeacher)
    {
      aStudent.setTeacher(this);
    }
    else
    {
      students.add(aStudent);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeStudent(Student aStudent)
  {
    boolean wasRemoved = false;
    //Unable to remove aStudent, as it must always have a teacher
    if (!this.equals(aStudent.getTeacher()))
    {
      students.remove(aStudent);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addStudentAt(Student aStudent, int index)
  {  
    boolean wasAdded = false;
    if(addStudent(aStudent))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfStudents()) { index = numberOfStudents() - 1; }
      students.remove(aStudent);
      students.add(index, aStudent);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveStudentAt(Student aStudent, int index)
  {
    boolean wasAdded = false;
    if(students.contains(aStudent))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfStudents()) { index = numberOfStudents() - 1; }
      students.remove(aStudent);
      students.add(index, aStudent);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addStudentAt(aStudent, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=students.size(); i > 0; i--)
    {
      Student aStudent = students.get(i - 1);
      aStudent.delete();
    }
    super.delete();
  }


  public String toString()
  {
    return super.toString() + "["+
            "position" + ":" + getPosition()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

/**
 * This is a student
 * Multiple comments
 * on several lines
 */
// line 6 "../ClassTemplateTest_MultiLineComment.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 1 "AssociationInlineComment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Associations
  private List<Bar> bars;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {
    bars = new ArrayList<Bar>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public Bar getBar(int index)
  {
    Bar aBar = bars.get(index);
    return aBar;
  }

  /**
   * I am a inline comment above an association.
   */
  public List<Bar> getBars()
  {
    List<Bar> newBars = Collections.unmodifiableList(bars);
    return newBars;
  }

  public int numberOfBars()
  {
    int number = bars.size();
    return number;
  }

  public boolean hasBars()
  {
    boolean has = bars.size() > 0;
    return has;
  }

  public int indexOfBar(Bar aBar)
  {
    int index = bars.indexOf(aBar);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfBars()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Bar addBar()
  {
    return new Bar(this);
  }

  public boolean addBar(Bar aBar)
  {
    boolean wasAdded = false;
    if (bars.contains(aBar)) { return false; }
    Foo existingFoo = aBar.getFoo();
    boolean isNewFoo = existingFoo != null && !this.equals(existingFoo);
    if (isNewFoo)
    {
      aBar.setFoo(this);
    }
    else
    {
      bars.add(aBar);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeBar(Bar aBar)
  {
    boolean wasRemoved = false;
    //Unable to remove aBar, as it must always have a foo
    if (!this.equals(aBar.getFoo()))
    {
      bars.remove(aBar);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addBarAt(Bar aBar, int index)
  {  
    boolean wasAdded = false;
    if(addBar(aBar))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBars()) { index = numberOfBars() - 1; }
      bars.remove(aBar);
      bars.add(index, aBar);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveBarAt(Bar aBar, int index)
  {
    boolean wasAdded = false;
    if(bars.contains(aBar))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBars()) { index = numberOfBars() - 1; }
      bars.remove(aBar);
      bars.add(index, aBar);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addBarAt(aBar, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=bars.size(); i > 0; i--)
    {
      Bar aBar = bars.get(i - 1);
      aBar.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;

/**
 * This is a student
 */
// line 5 "../ClassTemplateTest_GarbageComment.ump"
public class Student
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Student()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "MultipleMethodComments.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}


  /**
   * Inline comment above method.
   */
  // line 6 "MultipleMethodComments.ump"
  public void testMethod1(){
    // I am a comment inside a method.
  }


  /**
   * Multiple inline comments
   * above method.
   */
  // line 13 "MultipleMethodComments.ump"
  public void testMethod2(){
    // I am a comment inside a method.
  }


  /**
   * Multiline comment above method.
   */
  // line 19 "MultipleMethodComments.ump"
  public void testMethod3(){
    // I am a comment inside a method.
  }


  /**
   * Multiple multiline comments
   * above method.
   */
  // line 28 "MultipleMethodComments.ump"
  public void testMethod4(){
    // I am a comment inside a method.
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 1 "MultipleAssociationComments.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Associations
  private List<Bar1> bar1s;
  private List<Bar2> bar2s;
  private List<Bar3> bar3s;
  private List<Bar4> bar4s;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {
    bar1s = new ArrayList<Bar1>();
    bar2s = new ArrayList<Bar2>();
    bar3s = new ArrayList<Bar3>();
    bar4s = new ArrayList<Bar4>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public Bar1 getBar1(int index)
  {
    Bar1 aBar1 = bar1s.get(index);
    return aBar1;
  }

  /**
   * Inline comment above association.
   */
  public List<Bar1> getBar1s()
  {
    List<Bar1> newBar1s = Collections.unmodifiableList(bar1s);
    return newBar1s;
  }

  public int numberOfBar1s()
  {
    int number = bar1s.size();
    return number;
  }

  public boolean hasBar1s()
  {
    boolean has = bar1s.size() > 0;
    return has;
  }

  public int indexOfBar1(Bar1 aBar1)
  {
    int index = bar1s.indexOf(aBar1);
    return index;
  }
  /* Code from template association_GetMany */
  public Bar2 getBar2(int index)
  {
    Bar2 aBar2 = bar2s.get(index);
    return aBar2;
  }

  /**
   * Multiple inline comments
   * above association.
   */
  public List<Bar2> getBar2s()
  {
    List<Bar2> newBar2s = Collections.unmodifiableList(bar2s);
    return newBar2s;
  }

  public int numberOfBar2s()
  {
    int number = bar2s.size();
    return number;
  }

  public boolean hasBar2s()
  {
    boolean has = bar2s.size() > 0;
    return has;
  }

  public int indexOfBar2(Bar2 aBar2)
  {
    int index = bar2s.indexOf(aBar2);
    return index;
  }
  /* Code from template association_GetMany */
  public Bar3 getBar3(int index)
  {
    Bar3 aBar3 = bar3s.get(index);
    return aBar3;
  }

  /**
   * Multiline comment above association.
   */
  public List<Bar3> getBar3s()
  {
    List<Bar3> newBar3s = Collections.unmodifiableList(bar3s);
    return newBar3s;
  }

  public int numberOfBar3s()
  {
    int number = bar3s.size();
    return number;
  }

  public boolean hasBar3s()
  {
    boolean has = bar3s.size() > 0;
    return has;
  }

  public int indexOfBar3(Bar3 aBar3)
  {
    int index = bar3s.indexOf(aBar3);
    return index;
  }
  /* Code from template association_GetMany */
  public Bar4 getBar4(int index)
  {
    Bar4 aBar4 = bar4s.get(index);
    return aBar4;
  }

  /**
   * Multiple multiline comments
   * above association.
   */
  public List<Bar4> getBar4s()
  {
    List<Bar4> newBar4s = Collections.unmodifiableList(bar4s);
    return newBar4s;
  }

  public int numberOfBar4s()
  {
    int number = bar4s.size();
    return number;
  }

  public boolean hasBar4s()
  {
    boolean has = bar4s.size() > 0;
    return has;
  }

  public int indexOfBar4(Bar4 aBar4)
  {
    int index = bar4s.indexOf(aBar4);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfBar1s()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Bar1 addBar1()
  {
    return new Bar1(this);
  }

  public boolean addBar1(Bar1 aBar1)
  {
    boolean wasAdded = false;
    if (bar1s.contains(aBar1)) { return false; }
    Foo existingFoo = aBar1.getFoo();
    boolean isNewFoo = existingFoo != null && !this.equals(existingFoo);
    if (isNewFoo)
    {
      aBar1.setFoo(this);
    }
    else
    {
      bar1s.add(aBar1);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeBar1(Bar1 aBar1)
  {
    boolean wasRemoved = false;
    //Unable to remove aBar1, as it must always have a foo
    if (!this.equals(aBar1.getFoo()))
    {
      bar1s.remove(aBar1);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addBar1At(Bar1 aBar1, int index)
  {  
    boolean wasAdded = false;
    if(addBar1(aBar1))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar1s()) { index = numberOfBar1s() - 1; }
      bar1s.remove(aBar1);
      bar1s.add(index, aBar1);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveBar1At(Bar1 aBar1, int index)
  {
    boolean wasAdded = false;
    if(bar1s.contains(aBar1))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar1s()) { index = numberOfBar1s() - 1; }
      bar1s.remove(aBar1);
      bar1s.add(index, aBar1);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addBar1At(aBar1, index);
    }
    return wasAdded;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfBar2s()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Bar2 addBar2()
  {
    return new Bar2(this);
  }

  public boolean addBar2(Bar2 aBar2)
  {
    boolean wasAdded = false;
    if (bar2s.contains(aBar2)) { return false; }
    Foo existingFoo = aBar2.getFoo();
    boolean isNewFoo = existingFoo != null && !this.equals(existingFoo);
    if (isNewFoo)
    {
      aBar2.setFoo(this);
    }
    else
    {
      bar2s.add(aBar2);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeBar2(Bar2 aBar2)
  {
    boolean wasRemoved = false;
    //Unable to remove aBar2, as it must always have a foo
    if (!this.equals(aBar2.getFoo()))
    {
      bar2s.remove(aBar2);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addBar2At(Bar2 aBar2, int index)
  {  
    boolean wasAdded = false;
    if(addBar2(aBar2))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar2s()) { index = numberOfBar2s() - 1; }
      bar2s.remove(aBar2);
      bar2s.add(index, aBar2);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveBar2At(Bar2 aBar2, int index)
  {
    boolean wasAdded = false;
    if(bar2s.contains(aBar2))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar2s()) { index = numberOfBar2s() - 1; }
      bar2s.remove(aBar2);
      bar2s.add(index, aBar2);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addBar2At(aBar2, index);
    }
    return wasAdded;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfBar3s()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Bar3 addBar3()
  {
    return new Bar3(this);
  }

  public boolean addBar3(Bar3 aBar3)
  {
    boolean wasAdded = false;
    if (bar3s.contains(aBar3)) { return false; }
    Foo existingFoo = aBar3.getFoo();
    boolean isNewFoo = existingFoo != null && !this.equals(existingFoo);
    if (isNewFoo)
    {
      aBar3.setFoo(this);
    }
    else
    {
      bar3s.add(aBar3);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeBar3(Bar3 aBar3)
  {
    boolean wasRemoved = false;
    //Unable to remove aBar3, as it must always have a foo
    if (!this.equals(aBar3.getFoo()))
    {
      bar3s.remove(aBar3);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addBar3At(Bar3 aBar3, int index)
  {  
    boolean wasAdded = false;
    if(addBar3(aBar3))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar3s()) { index = numberOfBar3s() - 1; }
      bar3s.remove(aBar3);
      bar3s.add(index, aBar3);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveBar3At(Bar3 aBar3, int index)
  {
    boolean wasAdded = false;
    if(bar3s.contains(aBar3))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar3s()) { index = numberOfBar3s() - 1; }
      bar3s.remove(aBar3);
      bar3s.add(index, aBar3);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addBar3At(aBar3, index);
    }
    return wasAdded;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfBar4s()
  {
    return 0;
  }
  /* Code from template association_AddManyToOne */
  public Bar4 addBar4()
  {
    return new Bar4(this);
  }

  public boolean addBar4(Bar4 aBar4)
  {
    boolean wasAdded = false;
    if (bar4s.contains(aBar4)) { return false; }
    Foo existingFoo = aBar4.getFoo();
    boolean isNewFoo = existingFoo != null && !this.equals(existingFoo);
    if (isNewFoo)
    {
      aBar4.setFoo(this);
    }
    else
    {
      bar4s.add(aBar4);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeBar4(Bar4 aBar4)
  {
    boolean wasRemoved = false;
    //Unable to remove aBar4, as it must always have a foo
    if (!this.equals(aBar4.getFoo()))
    {
      bar4s.remove(aBar4);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addBar4At(Bar4 aBar4, int index)
  {  
    boolean wasAdded = false;
    if(addBar4(aBar4))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar4s()) { index = numberOfBar4s() - 1; }
      bar4s.remove(aBar4);
      bar4s.add(index, aBar4);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveBar4At(Bar4 aBar4, int index)
  {
    boolean wasAdded = false;
    if(bar4s.contains(aBar4))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfBar4s()) { index = numberOfBar4s() - 1; }
      bar4s.remove(aBar4);
      bar4s.add(index, aBar4);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addBar4At(aBar4, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=bar1s.size(); i > 0; i--)
    {
      Bar1 aBar1 = bar1s.get(i - 1);
      aBar1.delete();
    }
    for(int i=bar2s.size(); i > 0; i--)
    {
      Bar2 aBar2 = bar2s.get(i - 1);
      aBar2.delete();
    }
    for(int i=bar3s.size(); i > 0; i--)
    {
      Bar3 aBar3 = bar3s.get(i - 1);
      aBar3.delete();
    }
    for(int i=bar4s.size(); i > 0; i--)
    {
      Bar4 aBar4 = bar4s.get(i - 1);
      aBar4.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "MethodInlineComment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}


  /**
   * I am a comment above a method.
   */
  // line 6 "MethodInlineComment.ump"
  public void testMethod(){
    // I am a comment inside a method.
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/


import java.util.*;

// line 1 "ClassTemplateTest_AbstractClassAvoidingInstantiation2.ump"
public class Teacher
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Teacher Associations
  private List<Foo> myFooss;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Teacher()
  {
    myFooss = new ArrayList<Foo>();
  }

  //------------------------
  // INTERFACE
  //------------------------
  /* Code from template association_GetMany */
  public Foo getMyFooss(int index)
  {
    Foo aMyFooss = myFooss.get(index);
    return aMyFooss;
  }

  public List<Foo> getMyFooss()
  {
    List<Foo> newMyFooss = Collections.unmodifiableList(myFooss);
    return newMyFooss;
  }

  public int numberOfMyFooss()
  {
    int number = myFooss.size();
    return number;
  }

  public boolean hasMyFooss()
  {
    boolean has = myFooss.size() > 0;
    return has;
  }

  public int indexOfMyFooss(Foo aMyFooss)
  {
    int index = myFooss.indexOf(aMyFooss);
    return index;
  }
  /* Code from template association_MinimumNumberOfMethod */
  public static int minimumNumberOfMyFooss()
  {
    return 0;
  }
  /* Code from template association_MaximumNumberOfMethod */
  public static int maximumNumberOfMyFooss()
  {
    return 2;
  }
  /* Code from template association_AddOptionalNToOne */


  public boolean addMyFooss(Foo aMyFooss)
  {
    boolean wasAdded = false;
    if (myFooss.contains(aMyFooss)) { return false; }
    if (numberOfMyFooss() >= maximumNumberOfMyFooss())
    {
      return wasAdded;
    }

    Teacher existingTeacher = aMyFooss.getTeacher();
    boolean isNewTeacher = existingTeacher != null && !this.equals(existingTeacher);
    if (isNewTeacher)
    {
      aMyFooss.setTeacher(this);
    }
    else
    {
      myFooss.add(aMyFooss);
    }
    wasAdded = true;
    return wasAdded;
  }

  public boolean removeMyFooss(Foo aMyFooss)
  {
    boolean wasRemoved = false;
    //Unable to remove aMyFooss, as it must always have a teacher
    if (!this.equals(aMyFooss.getTeacher()))
    {
      myFooss.remove(aMyFooss);
      wasRemoved = true;
    }
    return wasRemoved;
  }
  /* Code from template association_AddIndexControlFunctions */
  public boolean addMyFoossAt(Foo aMyFooss, int index)
  {  
    boolean wasAdded = false;
    if(addMyFooss(aMyFooss))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMyFooss()) { index = numberOfMyFooss() - 1; }
      myFooss.remove(aMyFooss);
      myFooss.add(index, aMyFooss);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveMyFoossAt(Foo aMyFooss, int index)
  {
    boolean wasAdded = false;
    if(myFooss.contains(aMyFooss))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfMyFooss()) { index = numberOfMyFooss() - 1; }
      myFooss.remove(aMyFooss);
      myFooss.add(index, aMyFooss);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addMyFoossAt(aMyFooss, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    for(int i=myFooss.size(); i > 0; i--)
    {
      Foo aMyFooss = myFooss.get(i - 1);
      aMyFooss.delete();
    }
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "MethodMultilineComment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}


  /**
   * I am a comment above a method.
   */
  // line 8 "MethodMultilineComment.ump"
  public void testMethod(){
    // I am a comment inside a method.
  }

}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/



// line 1 "AttributeInlineComment.ump"
public class Foo
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Foo Attributes
  private String bar;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Foo(String aBar)
  {
    bar = aBar;
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setBar(String aBar)
  {
    boolean wasSet = false;
    bar = aBar;
    wasSet = true;
    return wasSet;
  }

  /**
   * I am a inline comment above an attribute.
   */
  public String getBar()
  {
    return bar;
  }

  public void delete()
  {}


  public String toString()
  {
    return super.toString() + "["+
            "bar" + ":" + getBar()+ "]";
  }
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/

package example;
import java.util.Map;

// line 3 "../ClassTemplateTest_Depend.ump"
public class Mentor
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Mentor()
  {}

  //------------------------
  // INTERFACE
  //------------------------

  public void delete()
  {}

}