#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class Mentor:
    def __init__(self, aName, *allStudents):
        self._name = aName
        self._students = []
        if not self.setStudents(*allStudents):
            raise RuntimeError("Unable to create Mentor, must have 3 to 4 students. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html")

    def setName(self, aName):
        self._name = aName
        return True

    def getName(self):
        return self._name

    def getStudent(self, index):
        return self._students[index]

    def getStudents(self):
        return tuple(self._students)

    def numberOfStudents(self):
        return len(self._students)

    def hasStudents(self):
        return len(self._students) > 0

    def indexOfStudent(self, aStudent):
        return next((i for i, x in enumerate(self._students) if x is aStudent), -1)

    @staticmethod
    def minimumNumberOfStudents():
        return 3

    @staticmethod
    def maximumNumberOfStudents():
        return 4

    def addStudent(self, aStudent):
        if any(x is aStudent for x in self._students):
            return False
        if self.numberOfStudents() >= self.maximumNumberOfStudents():
            return False
        existingMentor = aStudent.getMentor()
        if existingMentor is not None and existingMentor.numberOfStudents() <= self.minimumNumberOfStudents():
            return False
        if existingMentor is not None:
            index = next((i for i, x in enumerate(existingMentor._students) if x is aStudent), -1)
            if index >= 0:
                del existingMentor._students[index]
        self._students.append(aStudent)
        aStudent._mentor = self
        return True

    def removeStudent(self, aStudent):
        index = next((i for i, x in enumerate(self._students) if x is aStudent), -1)
        if index < 0 or self.numberOfStudents() <= self.minimumNumberOfStudents():
            return False
        del self._students[index]
        aStudent._mentor = None
        return True

    def setStudents(self, *newStudents):
        if len(newStudents) < self.minimumNumberOfStudents() or len(newStudents) > self.maximumNumberOfStudents():
            return False
        checkNewStudents = set()
        mentorToNewStudents = {}
        for aStudent in newStudents:
            if id(aStudent) in checkNewStudents:
                return False
            existingMentor = aStudent.getMentor()
            if existingMentor is not None and existingMentor is not self:
                nextCount = mentorToNewStudents.get(id(existingMentor), existingMentor.numberOfStudents()) - 1
                if nextCount < 3:
                    return False
                mentorToNewStudents[id(existingMentor)] = nextCount
            checkNewStudents.add(id(aStudent))
        for orphan in self._students:
            if id(orphan) not in checkNewStudents:
                orphan._mentor = None
        self._students.clear()
        for aStudent in newStudents:
            existingMentor = aStudent.getMentor()
            if existingMentor is not None:
                index = next((i for i, x in enumerate(existingMentor._students) if x is aStudent), -1)
                if index >= 0:
                    del existingMentor._students[index]
            aStudent._mentor = self
            self._students.append(aStudent)
        return True

    def addStudentAt(self, aStudent, index):
        if not self.addStudent(aStudent):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfStudents():
            index = self.numberOfStudents() - 1
        del self._students[next((i for i, x in enumerate(self._students) if x is aStudent), -1)]
        self._students.insert(index, aStudent)
        return True

    def addOrMoveStudentAt(self, aStudent, index):
        if not any(x is aStudent for x in self._students):
            return self.addStudentAt(aStudent, index)
        if index < 0:
            index = 0
        if index > self.numberOfStudents():
            index = self.numberOfStudents() - 1
        del self._students[next((i for i, x in enumerate(self._students) if x is aStudent), -1)]
        self._students.insert(index, aStudent)
        return True

    def delete(self):
        for aStudent in self._students:
            aStudent._mentor = None
        self._students.clear()

    def __str__(self):
        return (super().__str__() + "["
                + "name:" + str(self.getName())
                + "]")

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class Student:
    def __init__(self, aNumber):
        self._number = aNumber
        self._mentor = None

    def setNumber(self, aNumber):
        self._number = aNumber
        return True

    def getNumber(self):
        return self._number

    def getMentor(self):
        return self._mentor

    def hasMentor(self):
        return self._mentor is not None

    def delete(self):
        if self._mentor is not None:
            if self._mentor.numberOfStudents() <= 3:
                self._mentor.delete()
            else:
                placeholderMentor = self._mentor
                self._mentor = None
                placeholderMentor.removeStudent(self)

    def __str__(self):
        return (super().__str__() + "["
                + "number:" + str(self.getNumber())
                + "]"
                + "\n  mentor = " + ("null" if self.getMentor() is None else format(id(self.getMentor()), "x")))