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) # TODO: Chceme, aby všechno nějak zvládlo None jako parametr. # 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 def first_brother(node): if node is None: return None brother = node while safe_pred(brother) is not None: brother = safe_pred(brother) return brother # A to samé pro .father_of_first def safe_father_of_first(node): first = first_brother(node) try: return first.father_of_first 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 pravých bratrů (konkrétně sebe a následujících potomků) # Generátor potomků níže spoléhá na to, že se tohle dá volat i s parametrem None. def me_and_right_brothers(node): current = node while current is not None: yield current current = current.succ def right_brothers(node): generator = me_and_right_brothers(node.succ) for item in generator: yield item # Generátor všech sourozenců (vč. sám sebe) def all_brothers(node): # Najdeme prvního bratra fb = first_brother(node) marb = me_and_right_brothers(fb) for cur in marb: yield cur def all_proper_brothers(node): all = all_brothers(node) for br in all: if br is node: continue yield br # 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" # Bez tohoto vrcholu def all_following(node): current = general_next(node) while current is not None: yield current current = general_next(current) ## 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(node, type): for current in right_brothers(node): if isinstance(current, type): return current return None def get_prev_brother_of_type(node, type): # Na tohle není rozumný generátor, ani ho asi nechceme, prostě to implementujeme cyklem. current = node while safe_pred(current) is not None: current = safe_pred(current) if isinstance(current, type): return current return None # Totéž pro "the-right-order" pořadí def get_next_node_of_type(node, type): for cur in all_folowing(node): if isinstance(cur, type): return cur return None def get_prev_node_of_type(node, type): # Na tohle není rozumný generátor, ani ho asi nechceme, prostě to implementujeme cyklem. current = node while general_prev(current) is not None: current = general_prev(current) if isinstance(current, type): return current return None # Editace stromu: def create_node_after(predecessor, type, **kwargs): new_node = type.objects.create(**kwargs) new_node.save() succ = predecessor.succ predecessor.succ = new_node predecessor.save() new_node.succ = succ new_node.save() # Vyrábí prvního syna, ostatní nalepí za (existují-li) def create_child(parent, type, **kwargs): new_node = type.objects.create(**kwargs) new_node.save() orig_child = parent.first_child parent.first_child = new_node parent.save() if orig_child is not None: # Přidáme původního prvního syna jako potomka nového vrcholu new_node.succ = orig_child new_node.save() 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): raise NotImplementedError("YAGNI (You aren't gonna need it).") 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