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


class Analyzer:
    def __init__(self):
        self._children = []
        self._parent = []

    def getChild(self, index):
        return self._children[index]

    def getChildren(self):
        return tuple(self._children)

    def numberOfChildren(self):
        return len(self._children)

    def hasChildren(self):
        return len(self._children) > 0

    def indexOfChild(self, aChild):
        return next((i for i, x in enumerate(self._children) if x is aChild), -1)

    def getParent1(self, index):
        return self._parent[index]

    def getParent2(self):
        return tuple(self._parent)

    def getParent(self, *args, **kwargs):
        bound = __class__._bindArguments(("index",), False, args, kwargs)
        if bound is not None and (isinstance(bound[0], int) and not isinstance(bound[0], bool)):
            return __class__.getParent1(self, *bound)
        bound = __class__._bindArguments((), False, args, kwargs)
        if bound is not None:
            return __class__.getParent2(self, *bound)
        raise TypeError("No method matches provided parameters")

    def numberOfParent(self):
        return len(self._parent)

    def hasParent(self):
        return len(self._parent) > 0

    def indexOfParent(self, aParent):
        return next((i for i, x in enumerate(self._parent) if x is aParent), -1)

    @staticmethod
    def minimumNumberOfChildren():
        return 0

    def addChild(self, aChild):
        if any(x is aChild for x in self._children):
            return False
        self._children.append(aChild)
        if aChild.indexOfParent(self) == -1 and not aChild.addParent(self):
            del self._children[next((i for i, x in enumerate(self._children) if x is aChild), -1)]
            return False
        return True

    def removeChild(self, aChild):
        oldIndex = next((i for i, x in enumerate(self._children) if x is aChild), -1)
        if oldIndex == -1:
            return False
        del self._children[oldIndex]
        if aChild.indexOfParent(self) != -1 and not aChild.removeParent(self):
            self._children.insert(oldIndex, aChild)
            return False
        return True

    def addChildAt(self, aChild, index):
        if not self.addChild(aChild):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfChildren():
            index = self.numberOfChildren() - 1
        del self._children[next((i for i, x in enumerate(self._children) if x is aChild), -1)]
        self._children.insert(index, aChild)
        return True

    def addOrMoveChildAt(self, aChild, index):
        if not any(x is aChild for x in self._children):
            return self.addChildAt(aChild, index)
        if index < 0:
            index = 0
        if index > self.numberOfChildren():
            index = self.numberOfChildren() - 1
        del self._children[next((i for i, x in enumerate(self._children) if x is aChild), -1)]
        self._children.insert(index, aChild)
        return True

    @staticmethod
    def minimumNumberOfParent():
        return 0

    def addParent(self, aParent):
        if any(x is aParent for x in self._parent):
            return False
        self._parent.append(aParent)
        if aParent.indexOfChild(self) == -1 and not aParent.addChild(self):
            del self._parent[next((i for i, x in enumerate(self._parent) if x is aParent), -1)]
            return False
        return True

    def removeParent(self, aParent):
        oldIndex = next((i for i, x in enumerate(self._parent) if x is aParent), -1)
        if oldIndex == -1:
            return False
        del self._parent[oldIndex]
        if aParent.indexOfChild(self) != -1 and not aParent.removeChild(self):
            self._parent.insert(oldIndex, aParent)
            return False
        return True

    def addParentAt(self, aParent, index):
        if not self.addParent(aParent):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfParent():
            index = self.numberOfParent() - 1
        del self._parent[next((i for i, x in enumerate(self._parent) if x is aParent), -1)]
        self._parent.insert(index, aParent)
        return True

    def addOrMoveParentAt(self, aParent, index):
        if not any(x is aParent for x in self._parent):
            return self.addParentAt(aParent, index)
        if index < 0:
            index = 0
        if index > self.numberOfParent():
            index = self.numberOfParent() - 1
        del self._parent[next((i for i, x in enumerate(self._parent) if x is aParent), -1)]
        self._parent.insert(index, aParent)
        return True

    def delete(self):
        copyOfChildren = tuple(self._children)
        self._children.clear()
        for aChild in copyOfChildren:
            aChild.removeParent(self)
        copyOfParent = tuple(self._parent)
        self._parent.clear()
        for aParent in copyOfParent:
            aParent.removeChild(self)

    @staticmethod
    def _bindArguments(names, varargs, args, kwargs):
        if len(args) > len(names) and not varargs:
            return None
        bound = list(args[:len(names)])
        for name in names[len(bound):]:
            if name not in kwargs:
                return None
            bound.append(kwargs[name])
        if len(kwargs) != len(names) - min(len(args), len(names)):
            return None
        if varargs:
            bound.append(args[len(names):])
        return bound

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


class Analyzer:
    def __init__(self):
        self._offspring = []

    def getOffspring1(self, index):
        return self._offspring[index]

    def getOffspring2(self):
        return tuple(self._offspring)

    def getOffspring(self, *args, **kwargs):
        bound = __class__._bindArguments(("index",), False, args, kwargs)
        if bound is not None and (isinstance(bound[0], int) and not isinstance(bound[0], bool)):
            return __class__.getOffspring1(self, *bound)
        bound = __class__._bindArguments((), False, args, kwargs)
        if bound is not None:
            return __class__.getOffspring2(self, *bound)
        raise TypeError("No method matches provided parameters")

    def numberOfOffspring(self):
        return len(self._offspring)

    def hasOffspring(self):
        return len(self._offspring) > 0

    def indexOfOffspring(self, aOffspring):
        return next((i for i, x in enumerate(self._offspring) if x is aOffspring), -1)

    @staticmethod
    def minimumNumberOfOffspring():
        return 0

    def addOffspring(self, aOffspring):
        if any(x is aOffspring for x in self._offspring):
            return False
        self._offspring.append(aOffspring)
        if aOffspring.indexOfParent(self) == -1 and not aOffspring.addParent(self):
            del self._offspring[next((i for i, x in enumerate(self._offspring) if x is aOffspring), -1)]
            return False
        return True

    def removeOffspring(self, aOffspring):
        oldIndex = next((i for i, x in enumerate(self._offspring) if x is aOffspring), -1)
        if oldIndex == -1:
            return False
        del self._offspring[oldIndex]
        if aOffspring.indexOfParent(self) != -1 and not aOffspring.removeParent(self):
            self._offspring.insert(oldIndex, aOffspring)
            return False
        return True

    def addOffspringAt(self, aOffspring, index):
        if not self.addOffspring(aOffspring):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfOffspring():
            index = self.numberOfOffspring() - 1
        del self._offspring[next((i for i, x in enumerate(self._offspring) if x is aOffspring), -1)]
        self._offspring.insert(index, aOffspring)
        return True

    def addOrMoveOffspringAt(self, aOffspring, index):
        if not any(x is aOffspring for x in self._offspring):
            return self.addOffspringAt(aOffspring, index)
        if index < 0:
            index = 0
        if index > self.numberOfOffspring():
            index = self.numberOfOffspring() - 1
        del self._offspring[next((i for i, x in enumerate(self._offspring) if x is aOffspring), -1)]
        self._offspring.insert(index, aOffspring)
        return True

    def delete(self):
        copyOfOffspring = tuple(self._offspring)
        self._offspring.clear()
        for aOffspring in copyOfOffspring:
            aOffspring.removeParent(self)

    @staticmethod
    def _bindArguments(names, varargs, args, kwargs):
        if len(args) > len(names) and not varargs:
            return None
        bound = list(args[:len(names)])
        for name in names[len(bound):]:
            if name not in kwargs:
                return None
            bound.append(kwargs[name])
        if len(kwargs) != len(names) - min(len(args), len(names)):
            return None
        if varargs:
            bound.append(args[len(names):])
        return bound