476 lines
14 KiB
Python
476 lines
14 KiB
Python
from django.core.exceptions import ObjectDoesNotExist
|
|
from django.db import transaction
|
|
# 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.
|
|
# TODO: Do nějakých consistency-checků přidat hledání polo-sirotků (kteří nesplňují invarianty, třeba nejsou dosažitelní a mají root, vyrábějí DAG, ...)
|
|
|
|
# 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
|
|
|
|
def get_upper_node_of_type(node, type):
|
|
# vrací první vyšší node daného typu (ignoruje sourozence)
|
|
if node is None:
|
|
return
|
|
current = node
|
|
while get_parent(current) is not None:
|
|
current = get_parent(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):
|
|
from .models import TreeNode
|
|
if predecessor is None:
|
|
raise TreeLibError("Nelze vyrábět sirotky! (predecessor=None)")
|
|
if not issubclass(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):
|
|
from .models import TreeNode
|
|
if parent is None:
|
|
raise TreeLibError("Nelze vyrábět sirotky! (parent=None)")
|
|
if not issubclass(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):
|
|
from .models import TreeNode
|
|
if successor is None:
|
|
raise TreeLibError("Nelze vyrábět sirotky! (successor=None)")
|
|
if not issubclass(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:
|
|
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: Trochu méně naivní, nevěřím tomu, prosím otestovat
|
|
D = node
|
|
C = get_parent(D)
|
|
if C is None:
|
|
raise TreeLibError("Nelze povýšit vrchol, jenž nemá otce.")
|
|
E = C.succ # Může být None a ničemu to nevadí
|
|
subtree4_head = D.first_child # Může být None, ale pak se musí z 3P udělat přímo potomek D
|
|
subtree4_tail = last_brother(subtree4_head) # Měl by být None právě když je sub4_head=None
|
|
subtree3P_head = D.succ # Může být None a ničemu to nevadí
|
|
subtree3L_tail = safe_pred(D) # Pokud je None, D je první syn C a C má tedy skončit bezdětný
|
|
|
|
# Prostor pro motlitbu...
|
|
pass
|
|
|
|
# Amen.
|
|
# Teď už nesmíme spadnout, protože jinak skončíme se stromem v nekonzistentním stavu
|
|
C.succ = D # Nespadne
|
|
C.save()
|
|
D.succ = E # Nespadne
|
|
D.save()
|
|
|
|
if subtree3L_tail is not None:
|
|
subtree3L_tail.succ = None
|
|
subtree3L_tail.save()
|
|
else:
|
|
assert C.first_child is D
|
|
C.first_child = None
|
|
C.save()
|
|
|
|
if subtree4_tail is not None:
|
|
subtree4_tail.succ = subtree3P_head
|
|
subtree4_tail.save()
|
|
else:
|
|
D.first_child = subtree3P_head
|
|
D.save()
|
|
|
|
# To by mělo být všechno...
|
|
|
|
# (lower bude jednoduchá rotace, ne mega, existence jednoduché rotace mi došla až po nakreslení obrázku)
|
|
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: Trochu naivní, prosím otestovat
|
|
C = node
|
|
D = C.succ # Může být None a ničemu to nevadí
|
|
B = safe_pred(C)
|
|
if B is None:
|
|
raise TreeLibError("Nelze ponížit prvního syna (není pod co)")
|
|
subtree2_head = B.first_child # Je-li None, pak se z C má stát první syn
|
|
subtree2_tail = last_brother(subtree2_head) # None iff head=None, doufám
|
|
|
|
# Prostor pro motlitbu...
|
|
pass
|
|
|
|
# Amen.
|
|
# Teď už nesmíme spadnout, protože jinak skončíme se stromem v nekonzistentním stavu
|
|
B.succ = D # Nespadne
|
|
B.save()
|
|
if subtree2_tail is not None:
|
|
subtree2_tail.succ = C
|
|
subtree2_tail.save()
|
|
else:
|
|
assert subtree2_head is None
|
|
B.first_child = C
|
|
B.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.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)
|