def get_comment_tree(self):

    class Node(object):
        def __init__(self, obj):
            self.obj = obj
            self.children = list()
            self.depth = -1

    root = Node(None)
    flat_lookup = {root.obj: root}
    flat_result = []

    for c in self.comments.filter(published=True):
        node = Node(c)
        flat_lookup[c.id] = node
        flat_lookup[c.reply_id].children.append(node)
        
    def traverse(root):
        for node in root.children:
            node.depth = root.depth + 1
            flat_result.append(node)
            traverse(node)

    traverse(root)
    return flat_result

object comments {
  type key = Int
  type entry = String
  type tree = Map[key, List[key]]
  type entries = Map[key, entry]

  def build(comments: List[(key, entry, key)]): (tree, entries) = {
    def insert(tree: tree, c: (key, entry, key)) = {
      val (child, _, parent) = c
      tree + (parent -> (child :: tree.getOrElse(parent, Nil)))
    }
    val tree = comments.foldLeft(Map[key, List[key]]())(insert)

    val entries = (Map[key, entry]() /: comments) {
      case (es, (key, entry, _)) => es + (key -> entry)
    }

    (tree, entries)
  }


  def dfs(tree: tree, entries: entries) {
    def step(depth: Int, key: key) {
      println("%s(%d, %s)" format ("-- " * depth, key, entries(key)))

      tree.getOrElse(key, Nil).foreach(k => step(depth + 1, k))
    }

    tree.getOrElse(0, Nil).foreach(k => step(0, k))
  }

  val cs = List[(Int, String, Int)](
      (1, "a", 0),
      (2, "b", 1),
      (3, "c", 1),
      (4, "d", 2),
      (5, "e", 0)
    )
}

/*
scala> val (t, e) = comments.build(comments.cs)
t: comments.tree = Map(0 -> List(5, 1), 1 -> List(3, 2), 2 -> List(4))
e: comments.entries = Map(5 -> e, 1 -> a, 2 -> b, 3 -> c, 4 -> d)

scala> comments.dfs(t, e)
(5, e)
(1, a)
-- (3, c)
-- (2, b)
-- -- (4, d)
*/

a = (object
    .ich()
    .bin()
    .eine()
    .method()
    .chain()
)

    class Spieler
    {
        string spielername;
        byte spielernummer;
        string spielerverein;

        //Konstruktoren
        public Spieler()
        {
            spielername = "Kein Name";
            spielernummer = 0;
            spielerverein = "Kein Verein";
        }

        public Spieler(string _sName, byte _sNummer, string _sVerein)
        {
            spielername = _sName;
            spielernummer = _sNummer;
            spielerverein = _sVerein;
        }

        //Methoden
        public void ShowSpieler()
        {
            Console.WriteLine("Spielername: {0} || Spielernummer: {1} || Spielerverein: {2}", spielername, spielernummer, spielerverein);
        }

        //Properties
        public string Name
        {
            get { return spielername; }
        }

        public string Verein
        {
            get { return spielerverein; }
        }

        public byte Nummer
        {
            get { return spielernummer; }
        }
    }

    class ProfiSpieler : Spieler
    {
        double praemieProTor;

        //Konstruktoren
        public ProfiSpieler()
        {
            praemieProTor = 0.0;
        }

        public ProfiSpieler(double _praemieProTor):base(_sName,_sNummer,_sVerein)
        {
            praemieProTor = _praemieProTor;
        }
    }

INPUT: H = (h_1, \dots, h_s)
 OUTPUT: Gröbnerbasis G = (g_1, \dots, g_t)
 INIT: G := H
 1. DO
 2.     G' := G
 3.     FOREACH p, q \in G', p \neq q
 4.         s = Rest(S(p, q), G)
 5.         IF s \neq 0 THEN G := G \cup \{s\}
 6.     NEXT
 7. UNTIL G = G'