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


class OneToMany:
    def __init__(self, aOneToMany):
        self._oneToMany = None
        if not self.setOneToMany(aOneToMany):
            raise RuntimeError("Unable to create OneToMany due to aOneToMany. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html")

    def getOneToMany(self):
        return self._oneToMany

    def setOneToMany(self, aNewOneToMany):
        if aNewOneToMany is None:
            return False
        self._oneToMany = aNewOneToMany
        return True

    def delete(self):
        self._oneToMany = None

#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._pupil = None
        self._ta = None

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

    def getNumber(self):
        return self._number

    def getPupil(self):
        return self._pupil

    def hasPupil(self):
        return self._pupil is not None

    def getTa(self):
        return self._ta

    def hasTa(self):
        return self._ta is not None

    def setPupil(self, aNewPupil):
        if aNewPupil is None:
            existingPupil = self._pupil
            self._pupil = None
            if existingPupil is not None and existingPupil.getTa() is not None:
                existingPupil.setTa(None)
            return True
        currentPupil = self._pupil
        if currentPupil is not None and currentPupil is not aNewPupil:
            currentPupil.setTa(None)
        self._pupil = aNewPupil
        existingTa = aNewPupil.getTa()
        if existingTa is not self:
            aNewPupil.setTa(self)
        return True

    def setTa(self, aNewTa):
        if aNewTa is None:
            existingTa = self._ta
            self._ta = None
            if existingTa is not None and existingTa.getPupil() is not None:
                existingTa.setPupil(None)
            return True
        currentTa = self._ta
        if currentTa is not None and currentTa is not aNewTa:
            currentTa.setPupil(None)
        self._ta = aNewTa
        existingPupil = aNewTa.getPupil()
        if existingPupil is not self:
            aNewTa.setPupil(self)
        return True

    def delete(self):
        if self._pupil is not None:
            self._pupil.setTa(None)
        if self._ta is not None:
            self._ta.setPupil(None)

    def __str__(self):
        return (super().__str__() + "["
                + "number:" + str(self.getNumber())
                + "]")

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


class OneSymmetric:
    def __init__(self, aName, aNumber, aNameForFriend, aNumberForFriend):
        self._name = aName
        self._number = aNumber
        self._friend = None
        self._friend = __class__.alternateConstructor(aNameForFriend, aNumberForFriend, self)

    @classmethod
    def alternateConstructor(cls, aName, aNumber, aFriend):
        self = cls.__new__(cls)
        __class__._alternateInit(self, aName, aNumber, aFriend)
        return self

    def _alternateInit(self, aName, aNumber, aFriend):
        self._name = aName
        self._number = aNumber
        self._friend = None
        if aFriend is None or aFriend.getFriend() is not None:
            raise RuntimeError("Unable to create OneSymmetric due to aFriend. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html")
        self._friend = aFriend

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

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

    def getName(self):
        return self._name

    def getNumber(self):
        return self._number

    def getFriend(self):
        return self._friend

    def delete(self):
        existingFriend = self._friend
        self._friend = None
        if existingFriend is not None:
            existingFriend.delete()

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

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


class OneSymmetricNoParam:
    def __init__(self):
        self._friend = None
        self._friend = __class__.alternateConstructor(self)

    @classmethod
    def alternateConstructor(cls, aFriend):
        self = cls.__new__(cls)
        __class__._alternateInit(self, aFriend)
        return self

    def _alternateInit(self, aFriend):
        self._friend = None
        if aFriend is None or aFriend.getFriend() is not None:
            raise RuntimeError("Unable to create OneSymmetricNoParam due to aFriend. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html")
        self._friend = aFriend

    def getFriend(self):
        return self._friend

    def delete(self):
        existingFriend = self._friend
        self._friend = None
        if existingFriend is not None:
            existingFriend.delete()

#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):
        self._name = aName
        self._superMentor = None

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

    def getName(self):
        return self._name

    def getSuperMentor(self):
        return self._superMentor

    def hasSuperMentor(self):
        return self._superMentor is not None

    def setSuperMentor(self, aNewSuperMentor):
        if aNewSuperMentor is None:
            existingSuperMentor = self._superMentor
            self._superMentor = None
            if existingSuperMentor is not None and existingSuperMentor.getSuperMentor() is not None:
                existingSuperMentor.setSuperMentor(None)
            return True
        currentSuperMentor = self._superMentor
        if currentSuperMentor is not None and currentSuperMentor is not aNewSuperMentor:
            currentSuperMentor.setSuperMentor(None)
        self._superMentor = aNewSuperMentor
        existingSuperMentor = aNewSuperMentor.getSuperMentor()
        if existingSuperMentor is not self:
            aNewSuperMentor.setSuperMentor(self)
        return True

    def delete(self):
        if self._superMentor is not None:
            self._superMentor.setSuperMentor(None)

    def __str__(self):
        return (super().__str__() + "["
                + "name:" + str(self.getName())
                + "]"
                + "\n  superMentor = " + ("null" if self.getSuperMentor() is None else format(id(self.getSuperMentor()), "x")))