from django.core.exceptions import ObjectDoesNotExist # NOTE: node.prev a node.succ jsou implementovány přímo v models.TreeNode # TODO: Všechny tyto funkce se naivně spoléhají na to, že jako parametr dostanou nějaký TreeNode (některé možná zvládnou i None) # Slouží k debugování pro rychlé získání představy o podobě podstromu pod tímto TreeNode. def print_tree(node,indent=0): # FIXME: Tady se spoléháme na to, že nedeklarovaný primární klíč se jmenuje by default 'id', což není úplně správně print("{}{} (id: {})".format(" "*indent,node, node.id)) if node.first_child: print_tree(node.first_child, indent=indent+2) if node.succ: print_tree(node.succ, indent=indent) # Django je trošku hloupé, takže node.prev nevrací None, ale hází django.core.exceptions.ObjectDoesNotExist def safe_pred(node): try: return node.prev except ObjectDoesNotExist: return None # A to samé pro .father_of_first def safe_father_of_first(node): return node.prev except ObjectDoesNotExist: return None ## Rodinné vztahy def get_parent(node): # Nejdřív získáme prvního potomka... while safe_pred(node) is not None: node = safe_pred(node) # ... a z prvního potomka umíme najít rodiče return safe_father_of_first(node) # Obecný next: další Node v "the-right-order" pořadí (já, pak potomci, pak sousedé) def general_next(node): # Máme potomka? if node.first_child is not None: return node.first_child # Nemáme potomka. # Chceme najít následníka sebe, nebo některého (toho nejblíž příbuzného) z našich předků (tatínka, dědečka, ...) while node.succ is None: node = get_parent(node) if node is None: return None # žádný z předků nemá následníka, takže žádny vrchol nenásleduje. return node.succ def last_brother(node): while node.succ is not None: node = node.succ return node def general_prev(node): # Předchůdce je buď rekurzivně poslední potomek předchůdce, nebo náš otec. # Otce vyřešíme nejdřív: if safe_pred(node) is None: return safe_father_of_first(node) pred = safe_pred(node) while pred.first_child is not None: pred = last_brother(pred.first_child) # pred nyní nemá žádné potomky, takže je to poslední rekurzivní potomek původního předchůdce return pred # Generátor bratrů # Generátor potomků níže spoléhá na to, že se tohle dá volat i s parametrem None. def all_brothers(node): current = node while current is not None: yield current current = current.succ # Generátor potomků def all_children(node): brothers = all_brothers(node.first_child) for br in brothers: yield br # Generátor následníků v "the-right-order" ## Filtrační hledání # Najdi dalšího bratra nějakého typu, nebo None. # hledá i podtřídy, i.e. get_next_brother_of_type(neco, TreeNode) je prostě succ. def get_next_brother_of_type(current, type): pass def get_prev_brother_of_type(current, type): pass # Totéž pro "the-right-order" pořadí def get_next_node_of_type(current, type): pass def get_next_node_of_type(current, type): pass # Editace stromu: def create_node_after(predecessor, type, **kwargs): pass # Vyrábí prvního syna, ostatní nalepí za (existují-li) def create_child(parent, type, **kwargs): pass def create_node_before(some, arguments, but, i, dont, know, which, yet): pass # Tohle bude hell. # ValueError, pokud je (aspoň) jeden parametr None def swap(node, other): pass def swap_pred(node): pass def swap_succ(node): pass # Rotace stromu # Dokumentace viz wiki: # (lower bude jednoduchá rotace, ne mega, existence jednoduché rotace mi došla až po nakreslení obrázku) def raise_node(node): pass def lower_node(node): pass