from django.core.exceptions import ObjectDoesNotExist from django.db import transaction from seminar.models import TreeNode # 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): if node is None: return None try: return node.prev except ObjectDoesNotExist: return None # FIXME: Proč????? def safe_succ(node): try: return node.succ except ObjectDoesNotExist: return None def safe_father_of_first(node): if node is None: return None first = first_brother(node) try: return first.father_of_first 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 ## Rodinné vztahy # Tohle se teď zrovna k None chová správně, ale je potřeba na to dávat pozor 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) def get_last_child(node): if node is None: return None first = node.first_child if first is None: return None else: return last_brother(first) def is_orphan(node): """ Zjišťuje, jestli už je daný Node někde pověšený či nikoli. """ # None jsem se rozhodl, že sirotek není if node is None: return False if get_parent(node) is None: if node.succ is not None or safe_pred(node) is not None or safe_father_of_first(node) is not None or node.root is not None: import logging logger = logging.getLogger(__name__) # Error = pošle mail :-) logger.error(f"Node-sirotek s id {node.id} má rodinné vztahy (Node: {node})") return True else: return False # Obecný next: další Node v "the-right-order" pořadí (já, pak potomci, pak sousedé) def general_next(node): if node is None: return None # 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): if node is None: return None 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: # Tady se ošetří node=None samo 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): if node is None: return 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): if node is None: return # 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): if node is None: return all = all_brothers(node) for br in all: if br is node: continue yield br def all_children(node): """ Generátor všech potomků zadaného Node. """ if node is None: return brothers = all_brothers(node.first_child) for br in brothers: yield br def all_children_of_type(node, type): """ Generuje všechny potomky daného Node a daného typu. """ if node is None: return brothers = all_brothers(node.first_child) for br in brothers: if isinstance(br, type): yield br # Generátor následníků v "the-right-order" # Bez tohoto vrcholu def all_following(node): if node is None: return 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): if node is None: return for current in right_brothers(node): if isinstance(current, type): return current return None def get_prev_brother_of_type(node, type): if node is None: return # 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): if node is None: return 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. if node is None: return current = node while general_prev(current) is not None: current = general_prev(current) if isinstance(current, type): return current return None # Exception, kterou některé metody při špatném použití mohou házet # Hlavní důvod je možnost informovat o selhání, aby se příslušný problém dal zobrazit na frontendu, class TreeLibError(RuntimeError): pass # Editace stromu: def create_node_after(predecessor, type, **kwargs): if predecessor is None: raise TreeLibError("Nelze vyrábět sirotky! (predecessor=None)") if not isinstance(type, TreeNode): raise TreeLibError("Nový node není node!") new_node = type.objects.create(**kwargs) new_node.root = predecessor.root new_node.save() succ = predecessor.succ predecessor.succ = new_node predecessor.save() new_node.succ = succ new_node.save() return new_node # Vyrábí prvního syna, ostatní nalepí za (existují-li) def create_child(parent, type, **kwargs): if parent is None: raise TreeLibError("Nelze vyrábět sirotky! (parent=None)") if not isinstance(type, TreeNode): raise TreeLibError("Nový node není node!") new_node = type.objects.create(**kwargs) new_node.root = parent.root 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() return new_node def insert_last_child(parent, node): if parent is None: raise TreeLibError("Nelze vyrábět sirotky! (parent=None)") """ Zadaný Node přidá jako posledního potomka otce. """ last = get_last_child(parent) if not is_orphan(node): print(safe_pred(node)) print(safe_father_of_first(node)) if len(safe_father_of_first(node).get_real_instances()) == 0: print("Related Manager je prázdný.") print(type(safe_father_of_first(node).queryset_class)) raise TreeLibError("Snažíš se přidat do stromu Node, který už je zavěšený.") if last is None: parent.first_child = node parent.save() else: last.succ = node last.save() def create_node_before(successor, type, **kwargs): if successor is None: raise TreeLibError("Nelze vyrábět sirotky! (successor=None)") if not isinstance(type, TreeNode): raise TreeLibError("Nový node není node!") if safe_pred(successor) is not None: # Easy: přidáme za předchůdce create_node_after(successor.prev, type, **kwargs) # Nemáme předchůdce, jsme tedy první z bratrů. Máme otce? if safe_father_of_first(successor) is not None: # Ano -> Easy: vyrobíme nového potomka # NOTE: Tohle je možná trošku abuse implementace výše, ale to nevadí moc... create_child(successor.father_of_first, type, **kwargs) # Teď už easy: Jsme sirotci, takže se vyrobíme a našeho následníka si přidáme jako succ new = type.objects.create(**kwargs) new.root = successor.root new.succ = successor new.save() return new # ValueError, pokud je (aspoň) jeden parametr None def swap(node, other): raise NotImplementedError("YAGNI (You aren't gonna need it).") @transaction.atomic def swap_succ(node): if node is None: raise TreeLibError("Nelze přesunout None. Tohle by se nemělo stát.") succ = node.succ if succ is None: raise TreeLibError("Nelze posunout vpravo, není tam žádný další uzel") pred = safe_pred(node) post_succ = succ.succ if pred is not None: pred.succ = None pred.save() # Nemame predchudce -> je potreba upravit otce father = safe_father_of_first(node) if pred is None and father is not None: # Mame otce father.first_child = succ father.save() succ.succ = node succ.save() node.succ = post_succ node.save() if pred is not None: pred.succ = succ pred.save() @transaction.atomic def swap_pred(node): if node is None: raise TreeLibError("Nelze přesunout None. Tohle by se nemělo stát.") pred = safe_pred(node) if pred is None: raise TreeLibError("Nelze posunout vlevo, není tam žádný další uzel.") return swap_succ(pred) # 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): if node is None: raise TreeLibError("Nelze přesunout None. Tohle by se nemělo stát.") # Pojmenování viz WIKI (as of 2020-03-19 01:33:44 GMT+1) # FIXME: Velmi naivní, chybí error checky D = node C = get_parent(D) E = C.succ subtree4_head = D.first_child subtree4_tail = last_brother(subtree4_head) subtree3P_head = D.succ subtree3L_head = C.first_child subtree3L_tail = safe_pred(D) # Prostor pro motlitbu... pass # Amen. C.succ = D C.save() D.succ = E D.save() subtree3L_tail.succ = None subtree3L_tail.save() subtree4_tail.succ = subtree3P.head subtree4_tail.save() # To by mělo být všechno... def lower_node(node): if node is None: raise TreeLibError("Nelze přesunout None. Tohle by se nemělo stát.") # Pojmenování viz WIKI (as of 2020-03-19 01:33:44 GMT+1) # FIXME: Velmi naivní, chybí error checky C = node D = C.succ B = safe_pred(C) subtree2_head = B.first_child subtree2_tail = last_brother(subtree2_head) # Prostor pro motlitbu... pass # Amen. B.succ = D B.save() subtree2_tail.succ = C subtree2_tail.save() # To by mělo být všechno... def disconnect_node(node): #FIXME: dodělat odstranění roota všem potomkům if node is None: raise TreeLibError("Nelze odpojit None. Tohle by se nemělo stát.") print(f'My:{node}, predchudce:{safe_pred(node)}, naslednik:{safe_succ(node)}, otec:{safe_father_of_first(node)}') # Jsme prvnim synem if safe_pred(node) is None: if safe_succ(node) is None: # Jsme jedinym synem - upravime otce (pokud mame) a odpojime se father = safe_father_of_first(node) if father is not None: father.first_child = None father.save() return else: # mame bratra swap_succ(node) # Staneme se neprvním synem, pokracujeme mimo if # Jsme neprvním synem prev = node.prev prev.succ = node.succ node.prev = None node.succ = None node.save() clear_root(node) prev.save() def clear_root(node): node.root = None node.save() if node.first_child: clear_root(node.first_child) if node.succ: clear_root(node.succ) def set_root(node,root): node.root = root node.save() if node.first_child: clear_root(node.first_child) if node.succ: clear_root(node.succ)