= Modulo PeerServices - Metodi helper =
<<TableOfContents(4)>>

== my_gnode_participates ==
Questo metodo dice se il mio g-nodo di livello lvl partecipa attivamente al servizio con identificativo p_id.

Firma: '''bool my_gnode_participates(int p_id, int lvl)'''

 * Se services.has_key(p_id):
  * Return True.
 * Se (! participant_maps.has_key(p_id)):
  * Return False.
 * ''map'' = participant_maps[p_id].
 * Per ogni HCoord ''g'' in map.participant_list:
  * Se g.lvl < lvl:
   * Return True.
 * Return False.

== get_non_participant_gnodes ==
Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che, stando alle mie conoscenze, non partecipano al servizio con identificativo p_id.

Firma: '''List<HCoord> get_non_participant_gnodes(int p_id)'''

 * ''ret'' =  new !ArrayList di HCoord.
 * bool ''opzionale'' = False.
 * Se services.has_key(p_id):
  * opzionale = services[p_id].p_is_optional.
 * Altrimenti:
  * opzionale = True.
 * Se opzionale:
  * ''map'' = null.
  * Se (participant_maps.has_key(p_id)):
   * ''map'' = participant_maps[p_id].
  * Per ogni HCoord ''lp'' in get_all_gnodes_up_to_lvl(levels):
   * Se map = null:
    * Aggiungi a ret lp.
   * Altrimenti:
    * Se lp ∉ map.participant_list:
     * Aggiungi a ret lp.
 * Return ret.

== get_all_gnodes_up_to_lvl ==
Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che sono dentro il mio g-nodo di livello lvl. Compresi i singoli nodi e compreso me stesso (0, pos[0]).

Firma: '''List<HCoord> get_all_gnodes_up_to_lvl(int lvl)'''

 * ''ret'' =  new !ArrayList di HCoord.
 * Per ''l'' da 0 a lvl-1:
  * Per ''p'' da 0 a gsizes[l]-1:
   * Se pos[l] ≠ p:
    * Aggiungi a ret HCoord(l, p).
 * Aggiungi a ret HCoord(0, pos[0]).
 * Return ret.

== convert_tuple_gnode ==
Data un'istanza ''t'' di PeerTupleGNode il cui g-nodo di riferimento è uno dei g-nodi a cui il nodo corrente appartiene, questo metodo restituisce le seguenti informazioni:
  * int case:
   * Vale 1 se t rappresenta un g-nodo di cui il nodo corrente fa parte.
   * Vale 2 se t rappresenta un g-nodo visibile nella mia topologia come istanza di HCoord.
   * Vale 3 se t rappresenta un g-nodo non visibile nella mia topologia.
  * HCoord ret:
   * Il g-nodo che il nodo corrente ha in comune con h.
   * Nel caso 1 abbiamo ret.lvl = ε. Inoltre pos[ret.lvl] = ret.pos.
   * Nel caso 2 abbiamo ret.lvl = ε. Inoltre pos[ret.lvl] ≠ ret.pos.
   * Nel caso 3 abbiamo ret.lvl > ε.


Ricordiamo che un'istanza ''t'' di PeerTupleGNode rappresenta un g-nodo ''h'' di livello ''ε'' all'interno di un g-nodo (che chiamiamo g-nodo di riferimento) ''g'' di livello ''l''. Il valore di l è memorizzato in t.top. Il valore di ε si calcola come t.top - t.tuple.size.

Firma: '''void convert_tuple_gnode(PeerTupleGNode t, out int case, out HCoord ret)'''

 * int lvl = t.top.
 * int i = t.tuple.size.
 * assert(i > 0).
 * assert(i ≤ lvl).
 * ''trovato'' = False.
 * While True:
  * decrementa lvl di 1.
  * decrementa i di 1.
  * Se pos[lvl] ≠ t.tuple[i]:
   * ret = HCoord(lvl, t.tuple[i]).
   * trovato = True.
   * Se i = 0:
    * case = 2.
   * Altrimenti:
    * case = 3.
   * Esci dal ciclo.
  * Se i = 0:
   * ret = HCoord(lvl, t.tuple[i]).
   * case = 1.
   * Esci dal ciclo.
 * Return case, ret.

== make_tuple_gnode ==
Questo metodo produce un'istanza di PeerTupleGNode che rappresenta ''h'' nel nostro g-nodo di livello ''top''.

Firma: '''PeerTupleGNode make_tuple_gnode(HCoord h, int top)'''

 * assert(top > h.lvl).
 * ''tuple'' = [].
 * ''i'' = top.
 * While True:
  * Decrementa i di 1.
  * Se i = h.lvl:
   * Inserisci h.pos in posizione 0 in tuple.
   * Esci dal ciclo.
  * Altrimenti:
   * Inserisci pos[i] in posizione 0 in tuple.
 * Return new PeerTupleGNode(tuple, top).

== make_tuple_node ==
Questo metodo produce un'istanza di !PeerTupleNode che rappresenta ''h'' nel nostro g-nodo di livello ''top''. In realtà h è un g-nodo ma il risultato deve essere un !PeerTupleNode perché va usato nel calcolo di ''dist''. I valori delle posizioni inferiori a h.lvl non sono significativi purché rientrino nella topologia, quindi li impostiamo a 0.

Firma: '''!PeerTupleNode make_tuple_node(HCoord h, int top)'''

 * assert(top > h.lvl).
 * ''tuple'' = [].
 * ''i'' = top.
 * While i > 0:
  * Decrementa i di 1.
  * Se i > h.lvl:
   * Inserisci pos[i] in posizione 0 in tuple.
  * Se i = h.lvl:
   * Inserisci h.pos in posizione 0 in tuple.
  * Se i < h.lvl:
   * Inserisci 0 in posizione 0 in tuple.
 * Return new !PeerTupleNode(tuple).

== visible_by_someone_inside_my_gnode ==
Dato un g-nodo rappresentato da t, decidere se qualcuno dei nodi dentro il mio g-nodo di livello lvl può rappresentare quel g-nodo in forma di HCoord.

Firma: '''bool visible_by_someone_inside_my_gnode(PeerTupleGNode t, int lvl)'''

 * ''ε'' = t.top - t.tuple.size
 * ''l'' = ε.
 * Se l ≥ lvl-1:
  * l = l + 1.
 * Altrimenti:
  * l = lvl.
 * Se t.top ≤ l:
  * Return True.
 * # Calcola ''h'' il g-nodo di livello l in cui si trova g.
 * PeerTupleGNode ''h'' = new PeerTupleGNode(t.tuple.slice(l-ε, t.tuple.size), t.top).
 * # Ora scopriamo se h è uno dei g-nodi a cui appartiene n.
 * int ''case'', HCoord ''ret''.
 * convert_tuple_gnode(h, out case, out ret).
 * Se case = 1:
  * Return True.
 * Return False.