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

package example;
import java.util.*;

public class Student
{

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

  //Student Associations
  private Mentor m1;
  private Mentor m2;
  private List<Mentor> m3s;
  private List<Mentor> m4s;
  private List<Mentor> m5s;
  private List<Mentor> m6s;

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

  public Student(Mentor aM2, Mentor[] allM3s, Mentor[] allM4s, Mentor[] allM5s)
  {
    boolean didAddM2 = setM2(aM2);
    if (!didAddM2)
    {
      throw new RuntimeException("Unable to create two due to m2. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    m3s = new ArrayList<Mentor>();
    boolean didAddM3s = setM3s(allM3s);
    if (!didAddM3s)
    {
      throw new RuntimeException("Unable to create Student, must have 1 to 3 m3s. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    m4s = new ArrayList<Mentor>();
    boolean didAddM4s = setM4s(allM4s);
    if (!didAddM4s)
    {
      throw new RuntimeException("Unable to create Student, must have 4 to 7 m4s. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    m5s = new ArrayList<Mentor>();
    boolean didAddM5s = setM5s(allM5s);
    if (!didAddM5s)
    {
      throw new RuntimeException("Unable to create Student, must have at least 2 m5s. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
    }
    m6s = new ArrayList<Mentor>();
  }

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

  public Mentor getM1()
  {
    print "getM1";
    Mentor aM1 = m1;
    print "after getM1";
    return aM1;
  }

  public boolean hasM1()
  {
    boolean has = m1 != null;
    return has;
  }

  public Mentor getM2()
  {
    print "getM2";
    Mentor aM2 = m2;
    print "after getM2";
    return aM2;
  }

  public Mentor getM3(int index)
  {
    print "getM3";
    Mentor aM3 = m3s.get(index);
    print "after getM3";
    return aM3;
  }

  public List<Mentor> getM3s()
  {
    print "getM3s";
    List<Mentor> newM3s = Collections.unmodifiableList(m3s);
    print "after getM3s";
    return newM3s;
  }

  public int numberOfM3s()
  {
    print "numberOfM3s";
    int number = m3s.size();
    print "after numberOfM3s";
    return number;
  }

  public boolean hasM3s()
  {
    print "hasM3s";
    boolean has = m3s.size() > 0;
    print "after hasM3s";
    return has;
  }

  public int indexOfM3(Mentor aM3)
  {
    print "indexOfM3";
    int index = m3s.indexOf(aM3);
    print "after indexOfM3";
    return index;
  }

  public Mentor getM4(int index)
  {
    print "getM4";
    Mentor aM4 = m4s.get(index);
    print "after getM4";
    return aM4;
  }

  public List<Mentor> getM4s()
  {
    print "getM4s";
    List<Mentor> newM4s = Collections.unmodifiableList(m4s);
    print "after getM4s";
    return newM4s;
  }

  public int numberOfM4s()
  {
    print "numberOfM4s";
    int number = m4s.size();
    print "after numberOfM4s";
    return number;
  }

  public boolean hasM4s()
  {
    print "hasM4s";
    boolean has = m4s.size() > 0;
    print "after hasM4s";
    return has;
  }

  public int indexOfM4(Mentor aM4)
  {
    print "indexOfM4";
    int index = m4s.indexOf(aM4);
    print "after indexOfM4";
    return index;
  }

  public Mentor getM5(int index)
  {
    print "getM5";
    Mentor aM5 = m5s.get(index);
    print "after getM5";
    return aM5;
  }

  public List<Mentor> getM5s()
  {
    print "getM5s";
    List<Mentor> newM5s = Collections.unmodifiableList(m5s);
    print "after getM5s";
    return newM5s;
  }

  public int numberOfM5s()
  {
    print "numberOfM5s";
    int number = m5s.size();
    print "after numberOfM5s";
    return number;
  }

  public boolean hasM5s()
  {
    print "hasM5s";
    boolean has = m5s.size() > 0;
    print "after hasM5s";
    return has;
  }

  public int indexOfM5(Mentor aM5)
  {
    print "indexOfM5";
    int index = m5s.indexOf(aM5);
    print "after indexOfM5";
    return index;
  }

  public Mentor getM6(int index)
  {
    print "getM6";
    Mentor aM6 = m6s.get(index);
    print "after getM6";
    return aM6;
  }

  public List<Mentor> getM6s()
  {
    print "getM6s";
    List<Mentor> newM6s = Collections.unmodifiableList(m6s);
    print "after getM6s";
    return newM6s;
  }

  public int numberOfM6s()
  {
    print "numberOfM6s";
    int number = m6s.size();
    print "after numberOfM6s";
    return number;
  }

  public boolean hasM6s()
  {
    print "hasM6s";
    boolean has = m6s.size() > 0;
    print "after hasM6s";
    return has;
  }

  public int indexOfM6(Mentor aM6)
  {
    print "indexOfM6";
    int index = m6s.indexOf(aM6);
    print "after indexOfM6";
    return index;
  }

  public boolean setM1(Mentor aM1)
  {
    boolean wasSet = false;
    print "setM1";
    Mentor existingM1 = m1;
    m1 = aM1;
    if (existingM1 != null && !existingM1.equals(aM1))
    {
      existingM1.removeOne(this);
    }
    if (aM1 != null)
    {
      aM1.addOne(this);
    }
    wasSet = true;
    print "after setM1";
    return wasSet;
  }

  public boolean setM2(Mentor aM2)
  {
    boolean wasSet = false;
    print "setM2";
    if (aM2 == null)
    {
      print "after setM2";
      return wasSet;
    }

    Mentor existingM2 = m2;
    m2 = aM2;
    if (existingM2 != null && !existingM2.equals(aM2))
    {
      existingM2.removeTwo(this);
    }
    m2.addTwo(this);
    wasSet = true;
    print "after setM2";
    return wasSet;
  }

  public boolean isNumberOfM3sValid()
  {
    print "isNumberOfM3sValid";
    boolean isValid = numberOfM3s() >= minimumNumberOfM3s() && numberOfM3s() <= maximumNumberOfM3s();
    print "after isNumberOfM3sValid";
    return isValid;
  }

  public static int minimumNumberOfM3s()
  {
    print "minimumNumberOfM3s";
    int minimum = 1;
    print "after minimumNumberOfM3s";
    return minimum;
  }

  public static int maximumNumberOfM3s()
  {
    print "maximumNumberOfM3s";
    int maximum = 3;
    print "after maximumNumberOfM3s";
    return maximum;
  }

  public boolean addM3(Mentor aM3)
  {
    boolean wasAdded = false;
    print "addM3";
    if (m3s.contains(aM3)) { return false; }
    if (numberOfM3s() >= maximumNumberOfM3s())
    {
      print "after addM3";
      return wasAdded;
    }

    m3s.add(aM3);
    if (aM3.indexOfThree(this) != -1)
    {
      wasAdded = true;
    }
    else
    {
      wasAdded = aM3.addThree(this);
      if (!wasAdded)
      {
        m3s.remove(aM3);
      }
    }
    print "after addM3";
    return wasAdded;
  }

  public boolean removeM3(Mentor aM3)
  {
    boolean wasRemoved = false;
    print "before removeM3";
    if (!m3s.contains(aM3))
    {
      print "after removeM3";
      return wasRemoved;
    }

    if (numberOfM3s() <= minimumNumberOfM3s())
    {
      print "after removeM3";
      return wasRemoved;
    }

    int oldIndex = m3s.indexOf(aM3);
    m3s.remove(oldIndex);
    if (aM3.indexOfThree(this) == -1)
    {
      wasRemoved = true;
    }
    else
    {
      wasRemoved = aM3.removeThree(this);
      if (!wasRemoved)
      {
        m3s.add(oldIndex,aM3);
      }
    }
    print "after removeM3";
    return wasRemoved;
  }

  public boolean setM3s(Mentor... newM3s)
  {
    boolean wasSet = false;
    print "setM3s";
    ArrayList<Mentor> verifiedM3s = new ArrayList<Mentor>();
    for (Mentor aM3 : newM3s)
    {
      if (verifiedM3s.contains(aM3))
      {
        continue;
      }
      verifiedM3s.add(aM3);
    }

    if (verifiedM3s.size() != newM3s.length || verifiedM3s.size() < minimumNumberOfM3s() || verifiedM3s.size() > maximumNumberOfM3s())
    {
      print "after setM3s";
      return wasSet;
    }

    ArrayList<Mentor> oldM3s = new ArrayList<Mentor>(m3s);
    m3s.clear();
    for (Mentor aNewM3 : verifiedM3s)
    {
      m3s.add(aNewM3);
      if (oldM3s.contains(aNewM3))
      {
        oldM3s.remove(aNewM3);
      }
      else
      {
        aNewM3.addThree(this);
      }
    }

    for (Mentor anOldM3 : oldM3s)
    {
      anOldM3.removeThree(this);
    }
    wasSet = true;
    print "after setM3s";
    return wasSet;
  }

  public boolean addM3At(Mentor aM3, int index)
  {  
    boolean wasAdded = false;
    if(addM3(aM3))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM3s()) { index = numberOfM3s() - 1; }
      m3s.remove(aM3);
      m3s.add(index, aM3);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveM3At(Mentor aM3, int index)
  {
    boolean wasAdded = false;
    if(m3s.contains(aM3))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM3s()) { index = numberOfM3s() - 1; }
      m3s.remove(aM3);
      m3s.add(index, aM3);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addM3At(aM3, index);
    }
    return wasAdded;
  }

  public boolean isNumberOfM4sValid()
  {
    print "isNumberOfM4sValid";
    boolean isValid = numberOfM4s() >= minimumNumberOfM4s() && numberOfM4s() <= maximumNumberOfM4s();
    print "after isNumberOfM4sValid";
    return isValid;
  }

  public static int minimumNumberOfM4s()
  {
    print "minimumNumberOfM4s";
    int minimum = 4;
    print "after minimumNumberOfM4s";
    return minimum;
  }

  public static int maximumNumberOfM4s()
  {
    print "maximumNumberOfM4s";
    int maximum = 7;
    print "after maximumNumberOfM4s";
    return maximum;
  }

  public boolean addM4(Mentor aM4)
  {
    boolean wasAdded = false;
    print "addM4";
    if (m4s.contains(aM4)) { return false; }
    if (numberOfM4s() >= maximumNumberOfM4s())
    {
      print "after addM4";
      return wasAdded;
    }

    m4s.add(aM4);
    if (aM4.indexOfFour(this) != -1)
    {
      wasAdded = true;
    }
    else
    {
      wasAdded = aM4.addFour(this);
      if (!wasAdded)
      {
        m4s.remove(aM4);
      }
    }
    print "after addM4";
    return wasAdded;
  }

  public boolean removeM4(Mentor aM4)
  {
    boolean wasRemoved = false;
    print "removeM4";
    if (!m4s.contains(aM4))
    {
      print "after removeM4";
      return wasRemoved;
    }

    if (numberOfM4s() <= minimumNumberOfM4s())
    {
      print "after removeM4";
      return wasRemoved;
    }

    int oldIndex = m4s.indexOf(aM4);
    m4s.remove(oldIndex);
    if (aM4.indexOfFour(this) == -1)
    {
      wasRemoved = true;
    }
    else
    {
      wasRemoved = aM4.removeFour(this);
      if (!wasRemoved)
      {
        m4s.add(oldIndex,aM4);
      }
    }
    print "after removeM4";
    return wasRemoved;
  }

  public boolean setM4s(Mentor... newM4s)
  {
    boolean wasSet = false;
    print "setM4s";
    ArrayList<Mentor> verifiedM4s = new ArrayList<Mentor>();
    for (Mentor aM4 : newM4s)
    {
      if (verifiedM4s.contains(aM4))
      {
        continue;
      }
      verifiedM4s.add(aM4);
    }

    if (verifiedM4s.size() != newM4s.length || verifiedM4s.size() < minimumNumberOfM4s() || verifiedM4s.size() > maximumNumberOfM4s())
    {
      print "after setM4s";
      return wasSet;
    }

    ArrayList<Mentor> oldM4s = new ArrayList<Mentor>(m4s);
    m4s.clear();
    for (Mentor aNewM4 : verifiedM4s)
    {
      m4s.add(aNewM4);
      if (oldM4s.contains(aNewM4))
      {
        oldM4s.remove(aNewM4);
      }
      else
      {
        aNewM4.addFour(this);
      }
    }

    for (Mentor anOldM4 : oldM4s)
    {
      anOldM4.removeFour(this);
    }
    wasSet = true;
    print "after setM4s";
    return wasSet;
  }

  public boolean addM4At(Mentor aM4, int index)
  {  
    boolean wasAdded = false;
    if(addM4(aM4))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM4s()) { index = numberOfM4s() - 1; }
      m4s.remove(aM4);
      m4s.add(index, aM4);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveM4At(Mentor aM4, int index)
  {
    boolean wasAdded = false;
    if(m4s.contains(aM4))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM4s()) { index = numberOfM4s() - 1; }
      m4s.remove(aM4);
      m4s.add(index, aM4);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addM4At(aM4, index);
    }
    return wasAdded;
  }

  public boolean isNumberOfM5sValid()
  {
    print "isNumberOfM5sValid";
    boolean isValid = numberOfM5s() >= minimumNumberOfM5s();
    print "after isNumberOfM5sValid";
    return isValid;
  }

  public static int minimumNumberOfM5s()
  {
    print "minimumNumberOfM5s";
    int minimum = 2;
    print "after minimumNumberOfM5s";
    return minimum;
  }

  public boolean addM5(Mentor aM5)
  {
    boolean wasAdded = false;
    print "addM5";
    if (m5s.contains(aM5)) { return false; }
    m5s.add(aM5);
    if (aM5.indexOfFive(this) != -1)
    {
      wasAdded = true;
    }
    else
    {
      wasAdded = aM5.addFive(this);
      if (!wasAdded)
      {
        m5s.remove(aM5);
      }
    }
    print "after addM5";
    return wasAdded;
  }

  public boolean removeM5(Mentor aM5)
  {
    boolean wasRemoved = false;
    print "removeM5";
    if (!m5s.contains(aM5))
    {
      print "after removeM5";
      return wasRemoved;
    }

    if (numberOfM5s() <= minimumNumberOfM5s())
    {
      print "after removeM5";
      return wasRemoved;
    }

    int oldIndex = m5s.indexOf(aM5);
    m5s.remove(oldIndex);
    if (aM5.indexOfFive(this) == -1)
    {
      wasRemoved = true;
    }
    else
    {
      wasRemoved = aM5.removeFive(this);
      if (!wasRemoved)
      {
        m5s.add(oldIndex,aM5);
      }
    }
    print "after removeM5";
    return wasRemoved;
  }

  public boolean setM5s(Mentor... newM5s)
  {
    boolean wasSet = false;
    print "setM5s";
    ArrayList<Mentor> verifiedM5s = new ArrayList<Mentor>();
    for (Mentor aM5 : newM5s)
    {
      if (verifiedM5s.contains(aM5))
      {
        continue;
      }
      verifiedM5s.add(aM5);
    }

    if (verifiedM5s.size() != newM5s.length || verifiedM5s.size() < minimumNumberOfM5s())
    {
      print "after setM5s";
      return wasSet;
    }

    ArrayList<Mentor> oldM5s = new ArrayList<Mentor>(m5s);
    m5s.clear();
    for (Mentor aNewM5 : verifiedM5s)
    {
      m5s.add(aNewM5);
      if (oldM5s.contains(aNewM5))
      {
        oldM5s.remove(aNewM5);
      }
      else
      {
        aNewM5.addFive(this);
      }
    }

    for (Mentor anOldM5 : oldM5s)
    {
      anOldM5.removeFive(this);
    }
    wasSet = true;
    print "after setM5s";
    return wasSet;
  }

  public boolean addM5At(Mentor aM5, int index)
  {  
    boolean wasAdded = false;
    if(addM5(aM5))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM5s()) { index = numberOfM5s() - 1; }
      m5s.remove(aM5);
      m5s.add(index, aM5);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveM5At(Mentor aM5, int index)
  {
    boolean wasAdded = false;
    if(m5s.contains(aM5))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM5s()) { index = numberOfM5s() - 1; }
      m5s.remove(aM5);
      m5s.add(index, aM5);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addM5At(aM5, index);
    }
    return wasAdded;
  }

  public static int minimumNumberOfM6s()
  {
    return 0;
  }

  public boolean addM6(Mentor aM6)
  {
    boolean wasAdded = false;
    print "addM6";
    if (m6s.contains(aM6)) { return false; }
    m6s.add(aM6);
    if (aM6.indexOfSix(this) != -1)
    {
      wasAdded = true;
    }
    else
    {
      wasAdded = aM6.addSix(this);
      if (!wasAdded)
      {
        m6s.remove(aM6);
      }
    }
    print "after addM6";
    return wasAdded;
  }

  public boolean removeM6(Mentor aM6)
  {
    boolean wasRemoved = false;
    print "removeM6";
    if (!m6s.contains(aM6))
    {
      print "after removeM6";
      return wasRemoved;
    }

    int oldIndex = m6s.indexOf(aM6);
    m6s.remove(oldIndex);
    if (aM6.indexOfSix(this) == -1)
    {
      wasRemoved = true;
    }
    else
    {
      wasRemoved = aM6.removeSix(this);
      if (!wasRemoved)
      {
        m6s.add(oldIndex,aM6);
      }
    }
    print "after removeM6";
    return wasRemoved;
  }

  public boolean addM6At(Mentor aM6, int index)
  {  
    boolean wasAdded = false;
    if(addM6(aM6))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM6s()) { index = numberOfM6s() - 1; }
      m6s.remove(aM6);
      m6s.add(index, aM6);
      wasAdded = true;
    }
    return wasAdded;
  }

  public boolean addOrMoveM6At(Mentor aM6, int index)
  {
    boolean wasAdded = false;
    if(m6s.contains(aM6))
    {
      if(index < 0 ) { index = 0; }
      if(index > numberOfM6s()) { index = numberOfM6s() - 1; }
      m6s.remove(aM6);
      m6s.add(index, aM6);
      wasAdded = true;
    } 
    else 
    {
      wasAdded = addM6At(aM6, index);
    }
    return wasAdded;
  }

  public void delete()
  {
    if (m1 != null)
    {
      Mentor placeholderM1 = m1;
      this.m1 = null;
      placeholderM1.removeOne(this);
    }
    Mentor placeholderM2 = m2;
    this.m2 = null;
    if(placeholderM2 != null)
    {
      placeholderM2.removeTwo(this);
    }
    ArrayList<Mentor> copyOfM3s = new ArrayList<Mentor>(m3s);
    m3s.clear();
    for(Mentor aM3 : copyOfM3s)
    {
      aM3.removeThree(this);
    }
    ArrayList<Mentor> copyOfM4s = new ArrayList<Mentor>(m4s);
    m4s.clear();
    for(Mentor aM4 : copyOfM4s)
    {
      aM4.removeFour(this);
    }
    ArrayList<Mentor> copyOfM5s = new ArrayList<Mentor>(m5s);
    m5s.clear();
    for(Mentor aM5 : copyOfM5s)
    {
      aM5.removeFive(this);
    }
    ArrayList<Mentor> copyOfM6s = new ArrayList<Mentor>(m6s);
    m6s.clear();
    for(Mentor aM6 : copyOfM6s)
    {
      aM6.removeSix(this);
    }
  }

}
