// #include <Hierarchy.inc>

// ************************************************** Hierarchy CLASS *************************************************

Array garHierarchyPropertyMemory = create(10000, 20 );

// atomatic generated interface for class Hierarchy
Array garHierarchyMemory = create(10000, 4 );
int   giHierarchyHandleCount = 0;

Skip skFreeHierarchyNodes = create();
int giFreeHierarchyNodes = 0;

struct Hierarchy {};

// constructor & destructor for List
Hierarchy createHierarchy_ () {
    Hierarchy x = null
     
    if (giFreeHierarchyNodes > 0) {
        //print "Reallocating Stack Nr " giFreeHierarchyNodes "\n"
        if (!find(skFreeHierarchyNodes, giFreeHierarchyNodes--, x)) error "Hierarchy memory error!"               
    } else {
        x = (addr_ (++giHierarchyHandleCount) ) Hierarchy;
    }   
    //print "Allocated Hierarchy node " ((addr_ x) int) "\n"
    
    return x
}

Hierarchy getFirstChildNode  (Hierarchy x ) { return (get(garHierarchyMemory, (addr_ x) int, 0)) Hierarchy }
void setFirstChildNode (Hierarchy x, Hierarchy val) { put(garHierarchyMemory, val, (addr_ x) int, 0) }

Hierarchy getLastChildNode  (Hierarchy x ) { return (get(garHierarchyMemory, (addr_ x) int, 1)) Hierarchy }
void setLastChildNode (Hierarchy x, Hierarchy val) { put(garHierarchyMemory, val, (addr_ x) int, 1) }

Hierarchy getNextNode (Hierarchy x )     { return (get(garHierarchyMemory, (addr_ x) int, 2)) Hierarchy }
void setNextNode (Hierarchy x, Hierarchy val) { put(garHierarchyMemory, val, (addr_ x) int, 2) }

Hierarchy getParentNode  (Hierarchy x ) { return (get(garHierarchyMemory, (addr_ x) int, 3)) Hierarchy }
void setParentNode (Hierarchy x, Hierarchy val) { put(garHierarchyMemory, val, (addr_ x) int, 3) }


void getValue  (Hierarchy x, int index, _x &value)     { 
      int a = (get(garHierarchyPropertyMemory, (addr_ x) int, index)) int;  
      int &ref = addr_ value; 
      ref = a; 
}

void setValue (Hierarchy x, int index, _x val)      { 
      int iVal = val int; 
      put(garHierarchyPropertyMemory, iVal, (addr_ x) int, index) 
}

void getValue  (Hierarchy x, _x &value)     { 
      getValue(x, 0, value); 
}

void setValue (Hierarchy x, _x val)      { 
          setValue(x, 0, val); 
}


// **********************!!! INCREASE THIS IF YOU ADD A PROPERTY HERE !!!***************************** 
int giHierarchyPropertyCount = 4; 

void deleteHierarchy_ (Hierarchy &t) {
    // put in free list nodes
    Hierarchy deref = t
    if (null deref) {
        print "Trying to delete null Hierarchy at : " dxlHere()
        halt
    }
    put (skFreeHierarchyNodes, ++giFreeHierarchyNodes, deref, true)  
    // print "Freeing Hierarchy Slot: " (HierarchyHandle t) " Value " (strVal t) " in Stack Nr: " (giFreeHierarchyNodes-1) "\n"
    
    // Clear all properties to 0 here ...
    int handle = (addr_ deref) int; 
      int i; for (i = 0; i < giHierarchyPropertyCount; i++) put (garHierarchyMemory, 0, handle, i); 
}


Hierarchy createHierarchy () {
    Hierarchy node = createHierarchy_();
    setFirstChildNode(node, null); 
    setLastChildNode (node, null); 
    setNextNode(node, null); 
    setParentNode(node, null); 
    return node;
}

Hierarchy createNode(_x val) {
    Hierarchy node = createHierarchy();
    int iVal = val; 
    setValue(node, iVal); 
    return node; 
}


Skip childNodes(Hierarchy self, Skip sk) {
    int cnt = 0; 
    Hierarchy node = getFirstChildNode self; 
    setempty sk; 
      while (node != null) { put(sk, cnt++, node); node = getNextNode(node); }
      return sk; 
}

void deleteHierarchy(Hierarchy &t) {
    deleteHierarchy_ (t); 
}

void appendChildNode(Hierarchy t, Hierarchy child) {
    Hierarchy lastChild = getLastChildNode t; 
  if (null lastChild) {
      setFirstChildNode(t, child); 
  } else {
      setNextNode(lastChild, child); 
  }
  setLastChildNode(t, child); 
  while (child != null) { setParentNode(child, t); child = getNextNode(child); }
}

void insertNode(Hierarchy t, Hierarchy sibling) {
    Hierarchy nextChild = getNextNode t; 
    if (nextChild != null) {
          setNextNode(sibling, nextChild); 
    }
    setNextNode(t, sibling); 
    Hierarchy p = getParentNode t;
    while (sibling != null) { setParentNode(sibling, p); sibling = getNextNode sibling; }
}

void recurse(Hierarchy this, void func(Hierarchy, int), int level) {
    func(this,level); 
    Hierarchy node = getFirstChildNode this; 
    while (node != null) { recurse(node, func, level+1); node = getNextNode node; }
}

void recurse(Hierarchy this, bool func(Hierarchy, int), int level) {
    bool doChilds = func(this,level); 
    Hierarchy node = getFirstChildNode this; 
    if (doChilds) {
        while (node != null) { recurse(node, func, level+1); node = getNextNode node; }
    }
}

void recurse(Hierarchy this, void func(Hierarchy, int)) { recurse(this, func, 0); }
void recurse(Hierarchy this, bool func(Hierarchy, int)) { recurse(this, func, 0); }

Hierarchy HIERARCHY(Hierarchy h[]) {
     int i = sizeof h; 
     for (i = 1; i < sizeof h; i++) appendChildNode(h[0], h[i]); 
     return h[0]; 
}

/*
// Example 1: 
#include <Hierarchy.inc>

Hierarchy root = createNode(3); 

appendChildNode(root, createNode(33)); 
appendChildNode(root, createNode(44)); 

Skip sk = create(); 
Hierarchy node; for node in childNodes(root, sk) do {
    int val = 0; 
    getValue(node, val)
    print "Value: " val "\n"; 
}


// Example 2: 
Hierarchy someNode

Hierarchy x = HIERARCHY(createNode 33, 
                 createNode 55, 
                 HIERARCHY(createNode 11, 
                           someNode = createNode 12,
                           createNode 19
                 ),
                 createNode 14
            )

void func (Hierarchy n, int level) {
    int val = 0; 
    for (val = 0; val < level; val++) print "  "; 
    getValue(n, val); 
    print val "\n";
    
}

print "\n";
recurse(x, func) 

Hierarchy someParent = getParentNode someNode; 
int val; getValue(getParentNode someNode, val); 
print "Parent of 12 is: " val "\n"; 

*/