#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):
        self._mentors = []

    def getMentor(self, index):
        return self._mentors[index]

    def getMentors(self):
        return tuple(self._mentors)

    def numberOfMentors(self):
        return len(self._mentors)

    def hasMentors(self):
        return len(self._mentors) > 0

    def indexOfMentor(self, aMentor):
        return next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)

    @staticmethod
    def minimumNumberOfMentors():
        return 0

    def addMentor(self, aMentor):
        if any(x is aMentor for x in self._mentors):
            return False
        self._mentors.append(aMentor)
        if aMentor.indexOfStudent(self) == -1 and not aMentor.addStudent(self):
            del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
            return False
        return True

    def removeMentor(self, aMentor):
        oldIndex = next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)
        if oldIndex == -1:
            return False
        del self._mentors[oldIndex]
        if aMentor.indexOfStudent(self) != -1 and not aMentor.removeStudent(self):
            self._mentors.insert(oldIndex, aMentor)
            return False
        return True

    def addMentorAt(self, aMentor, index):
        if not self.addMentor(aMentor):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfMentors():
            index = self.numberOfMentors() - 1
        del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
        self._mentors.insert(index, aMentor)
        return True

    def addOrMoveMentorAt(self, aMentor, index):
        if not any(x is aMentor for x in self._mentors):
            return self.addMentorAt(aMentor, index)
        if index < 0:
            index = 0
        if index > self.numberOfMentors():
            index = self.numberOfMentors() - 1
        del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
        self._mentors.insert(index, aMentor)
        return True

    def delete(self):
        copyOfMentors = tuple(self._mentors)
        self._mentors.clear()
        for aMentor in copyOfMentors:
            aMentor.removeStudent(self)

#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):
        self._mentors = []

    def getMentor(self, index):
        return self._mentors[index]

    def getMentors(self):
        return tuple(self._mentors)

    def numberOfMentors(self):
        return len(self._mentors)

    def hasMentors(self):
        return len(self._mentors) > 0

    def indexOfMentor(self, aMentor):
        return next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)

    @staticmethod
    def minimumNumberOfMentors():
        return 0

    def addMentor(self, aMentor):
        if any(x is aMentor for x in self._mentors):
            return False
        self._mentors.append(aMentor)
        if aMentor.indexOfStudent(self) == -1 and not aMentor.addStudent(self):
            del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
            return False
        return True

    def removeMentor(self, aMentor):
        oldIndex = next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)
        if oldIndex == -1:
            return False
        del self._mentors[oldIndex]
        if aMentor.indexOfStudent(self) != -1 and not aMentor.removeStudent(self):
            self._mentors.insert(oldIndex, aMentor)
            return False
        return True

    def addMentorAt(self, aMentor, index):
        if not self.addMentor(aMentor):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfMentors():
            index = self.numberOfMentors() - 1
        del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
        self._mentors.insert(index, aMentor)
        return True

    def addOrMoveMentorAt(self, aMentor, index):
        if not any(x is aMentor for x in self._mentors):
            return self.addMentorAt(aMentor, index)
        if index < 0:
            index = 0
        if index > self.numberOfMentors():
            index = self.numberOfMentors() - 1
        del self._mentors[next((i for i, x in enumerate(self._mentors) if x is aMentor), -1)]
        self._mentors.insert(index, aMentor)
        return True

    def delete(self):
        copyOfMentors = tuple(self._mentors)
        self._mentors.clear()
        for aMentor in copyOfMentors:
            aMentor.removeStudent(self)

#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, aIntId, aDoubleId, aBooleanId, aStringId):
        self._cachedHashCode = None
        self._canSetIntId = True
        self._canSetDoubleId = True
        self._canSetBooleanId = True
        self._canSetStringId = True
        self._canSetStringListIds = True
        self._intId = aIntId
        self._doubleId = aDoubleId
        self._booleanId = aBooleanId
        self._stringId = aStringId
        self._stringListIds = []

    def setIntId(self, aIntId):
        if not self._canSetIntId:
            return False
        self._intId = aIntId
        return True

    def setDoubleId(self, aDoubleId):
        if not self._canSetDoubleId:
            return False
        self._doubleId = aDoubleId
        return True

    def setBooleanId(self, aBooleanId):
        if not self._canSetBooleanId:
            return False
        self._booleanId = aBooleanId
        return True

    def setStringId(self, aStringId):
        if not self._canSetStringId:
            return False
        self._stringId = aStringId
        return True

    def addStringListId(self, aStringListId):
        if not self._canSetStringListIds:
            return False
        self._stringListIds.append(aStringListId)
        return True

    def removeStringListId(self, aStringListId):
        if not self._canSetStringListIds:
            return False
        if aStringListId not in self._stringListIds:
            return False
        self._stringListIds.remove(aStringListId)
        return True

    def getIntId(self):
        return self._intId

    def getDoubleId(self):
        return self._doubleId

    def getBooleanId(self):
        return self._booleanId

    def getStringId(self):
        return self._stringId

    def getStringListId(self, index):
        return self._stringListIds[index]

    def getStringListIds(self):
        return list(self._stringListIds)

    def numberOfStringListIds(self):
        return len(self._stringListIds)

    def hasStringListIds(self):
        return len(self._stringListIds) > 0

    def indexOfStringListId(self, aStringListId):
        return self._stringListIds.index(aStringListId) if aStringListId in self._stringListIds else -1

    def isBooleanId(self):
        return self._booleanId

    def __eq__(self, obj):
        if type(obj) is not type(self):
            return NotImplemented
        return (self.getIntId(), self.getDoubleId(), self.getBooleanId(), self.getStringId(), tuple(self.getStringListIds())) == (obj.getIntId(), obj.getDoubleId(), obj.getBooleanId(), obj.getStringId(), tuple(obj.getStringListIds()))

    def __hash__(self):
        if self._cachedHashCode is None:
            self._cachedHashCode = hash((self.getIntId(), self.getDoubleId(), self.getBooleanId(), self.getStringId(), tuple(self.getStringListIds())))
            self._canSetIntId = False
            self._canSetDoubleId = False
            self._canSetBooleanId = False
            self._canSetStringId = False
            self._canSetStringListIds = False
        return self._cachedHashCode

    def equals(self, obj):
        return self == obj

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "stringId:" + str(self.getStringId()) + ","
                + "booleanId:" + str(self.getBooleanId()) + ","
                + "doubleId:" + str(self.getDoubleId()) + ","
                + "intId:" + str(self.getIntId())
                + "]")

#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, aDoubleId, aBooleanId, aStringId):
        self._cachedHashCode = None
        self._canSetIntId = True
        self._intId = 0
        self._doubleId = aDoubleId
        self._booleanId = aBooleanId
        self._stringId = aStringId

    def setIntId(self, aIntId):
        if not self._canSetIntId:
            return False
        self._canSetIntId = False
        self._intId = aIntId
        return True

    def getIntId(self):
        return self._intId

    def getDoubleId(self):
        return self._doubleId

    def getBooleanId(self):
        return self._booleanId

    def getStringId(self):
        return self._stringId

    def isBooleanId(self):
        return self._booleanId

    def __eq__(self, obj):
        if type(obj) is not type(self):
            return NotImplemented
        return (self.getIntId(), self.getDoubleId(), self.getBooleanId(), self.getStringId()) == (obj.getIntId(), obj.getDoubleId(), obj.getBooleanId(), obj.getStringId())

    def __hash__(self):
        if self._cachedHashCode is None:
            self._cachedHashCode = hash((self.getIntId(), self.getDoubleId(), self.getBooleanId(), self.getStringId()))
            self._canSetIntId = False
        return self._cachedHashCode

    def equals(self, obj):
        return self == obj

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "stringId:" + str(self.getStringId()) + ","
                + "booleanId:" + str(self.getBooleanId()) + ","
                + "doubleId:" + str(self.getDoubleId()) + ","
                + "intId:" + str(self.getIntId())
                + "]")

#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):
        self._cachedHashCode = None
        self._canSetMain = True
        self._canSetSecondaries = True
        self._main = None
        self._secondaries = []

    def getMain(self):
        return self._main

    def hasMain(self):
        return self._main is not None

    def getSecondary(self, index):
        return self._secondaries[index]

    def getSecondaries(self):
        return tuple(self._secondaries)

    def numberOfSecondaries(self):
        return len(self._secondaries)

    def hasSecondaries(self):
        return len(self._secondaries) > 0

    def indexOfSecondary(self, aSecondary):
        return next((i for i, x in enumerate(self._secondaries) if x is aSecondary), -1)

    def setMain(self, aNewMain):
        if not self._canSetMain:
            return False
        if aNewMain is None:
            existingMain = self._main
            self._main = None
            if existingMain is not None and existingMain.getMentorMain() is not None:
                existingMain.setMentorMain(None)
            return True
        currentMain = self._main
        if currentMain is not None and currentMain is not aNewMain:
            currentMain.setMentorMain(None)
        self._main = aNewMain
        existingMentorMain = aNewMain.getMentorMain()
        if existingMentorMain is not self:
            aNewMain.setMentorMain(self)
        return True

    @staticmethod
    def minimumNumberOfSecondaries():
        return 0

    def addSecondary(self, aSecondary):
        if not self._canSetSecondaries:
            return False
        if any(x is aSecondary for x in self._secondaries):
            return False
        existingMentorSecondary = aSecondary.getMentorSecondary()
        if existingMentorSecondary is None:
            if not aSecondary.setMentorSecondary(self):
                return False
        elif existingMentorSecondary is not self:
            if not existingMentorSecondary.removeSecondary(aSecondary):
                return False
            if not self.addSecondary(aSecondary):
                return False
        else:
            self._secondaries.append(aSecondary)
        return True

    def removeSecondary(self, aSecondary):
        if not self._canSetSecondaries:
            return False
        index = next((i for i, x in enumerate(self._secondaries) if x is aSecondary), -1)
        if index < 0:
            return False
        del self._secondaries[index]
        if not aSecondary.setMentorSecondary(None):
            self._secondaries.insert(index, aSecondary)
            return False
        return True

    def addSecondaryAt(self, aSecondary, index):
        if not self.addSecondary(aSecondary):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfSecondaries():
            index = self.numberOfSecondaries() - 1
        del self._secondaries[next((i for i, x in enumerate(self._secondaries) if x is aSecondary), -1)]
        self._secondaries.insert(index, aSecondary)
        return True

    def addOrMoveSecondaryAt(self, aSecondary, index):
        if not self._canSetSecondaries:
            return False
        if not any(x is aSecondary for x in self._secondaries):
            return self.addSecondaryAt(aSecondary, index)
        if index < 0:
            index = 0
        if index > self.numberOfSecondaries():
            index = self.numberOfSecondaries() - 1
        del self._secondaries[next((i for i, x in enumerate(self._secondaries) if x is aSecondary), -1)]
        self._secondaries.insert(index, aSecondary)
        return True

    def __eq__(self, obj):
        if type(obj) is not type(self):
            return NotImplemented
        return (self.getMain(), self.getSecondaries()) == (obj.getMain(), obj.getSecondaries())

    def __hash__(self):
        if self._cachedHashCode is None:
            self._cachedHashCode = hash((self.getMain(), self.getSecondaries()))
            self._canSetMain = False
            self._canSetSecondaries = False
        return self._cachedHashCode

    def equals(self, obj):
        return self == obj

    def delete(self):
        if self._main is not None:
            self._main.setMentorMain(None)
        for aSecondary in tuple(self._secondaries):
            aSecondary.setMentorSecondary(None)