Changeset 42

Show
Ignore:
Timestamp:
02/17/10 10:00:10 (2 years ago)
Author:
ke
Message:

First step towards a KahinaMemTree/KahinaDbTree? division. KahinaLayeredTree? not dealt with yet.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • kahina/trunk/src/org/kahina/breakpoint/TreeAutomaton.java

    r38 r42  
    77import org.kahina.control.KahinaController; 
    88import org.kahina.control.event.KahinaTreeMatchEvent; 
     9import org.kahina.data.tree.KahinaMemTree; 
    910import org.kahina.data.tree.KahinaTree; 
    1011 
    …… 
    4950        rules = new HashSet<TreeAutomatonRule>(); 
    5051         
    51         this.tree = new KahinaTree(); 
     52        this.tree = new KahinaMemTree(); 
    5253        this.annotations =  new HashMap<Integer,Set<Integer>>(); 
    5354        this.bp = bp;     

  • kahina/trunk/src/org/kahina/data/chart/KahinaChart.java

    r31 r42  
    88{ 
    99        static int lastID = 0; 
    10         static String type = "KahinaChart"; 
    1110 
    1211        public KahinaChart() 

  • kahina/trunk/src/org/kahina/data/chart/KahinaMemChart.java

    r12 r42  
    66import java.util.Set; 
    77 
    8 import org.kahina.data.KahinaMemObject; 
    9  
    10 public class KahinaMemChart extends KahinaChart implements KahinaMemObject 
     8public class KahinaMemChart extends KahinaChart 
    119{ 
    1210    //the chart is divided up into cells (vertical segments) that the edges can range over 

  • kahina/trunk/src/org/kahina/data/tree/KahinaLayeredTree.java

    r34 r42  
    99import org.w3c.dom.NodeList; 
    1010 
    11 public class KahinaLayeredTree extends KahinaTree 
     11public class KahinaLayeredTree extends KahinaMemTree 
    1212{    
    1313    //reference node should always be the same across views, so store it here 

  • kahina/trunk/src/org/kahina/data/tree/KahinaMemTree.java

    r34 r42  
    66import java.util.LinkedList; 
    77import java.util.List; 
    8  
    9 import org.kahina.core.data.KahinaObject; 
    10 import org.kahina.data.chart.KahinaChart; 
     8import java.util.Map; 
     9import java.util.Set; 
     10 
    1111import org.w3c.dom.Document; 
    1212import org.w3c.dom.Element; 
    …… 
    1414import org.w3c.dom.NodeList; 
    1515 
    16 public class KahinaTree extends KahinaObject 
     16public class KahinaMemTree extends KahinaTree 
    1717{ 
    1818    static int lastID = 0; 
    19     static String type = "KahinaTree"; 
    2019     
    2120    //empty tree has rootID = -1 
    …… 
    2322     
    2423    //encode properties of individual nodes 
    25     protected HashMap<Integer, Integer> parents; 
    26     protected HashMap<Integer, List<Integer>> children; 
    27     protected HashMap<Integer, String> nodeCaptions; //captions are displayed on the nodes 
    28     protected HashMap<Integer, String> edgeLabels; //labels are displayed on the edges to the parent 
    29     protected HashMap<Integer, Integer> status; //appearance of nodes can be steered by appearance 
    30     protected HashSet<Integer> collapsed; //node collapsing is stored in the model, not in individual views! 
     24    protected Map<Integer, Integer> parents; 
     25    protected Map<Integer, List<Integer>> children; 
     26    protected Map<Integer, String> nodeCaptions; //captions are displayed on the nodes 
     27    protected Map<Integer, String> edgeLabels; //labels are displayed on the edges to the parent 
     28    protected Map<Integer, Integer> status; //appearance of nodes can be steered by appearance 
     29    protected Set<Integer> collapsed; //node collapsing is stored in the model, not in individual views! 
    3130     
    3231    HashSet<Integer> terminals; //terminals will be displayed on one level 
    …… 
    3736    protected KahinaTree primaryModel; 
    3837     
    39     public KahinaTree() 
     38    public KahinaMemTree() 
    4039    { 
    4140        super(lastID++); 
    …… 
    5554    } 
    5655     
    57     public void setPrimaryModel(KahinaTree primaryModel) 
     56    @Override 
     57        public void setPrimaryModel(KahinaTree primaryModel) 
    5858    { 
    5959        this.primaryModel = primaryModel; 
    6060    } 
    6161     
    62     public int getRootID(int layerID) 
     62    @Override 
     63        public int getRootID(int layerID) 
    6364    { 
    6465        return rootID; 
    6566    } 
    6667     
    67     public void setRootID(int rootID) 
     68    @Override 
     69        public void setRootID(int rootID) 
    6870    { 
    6971        this.rootID = rootID; 
    7072    } 
    7173     
    72     public void addChild(int parent, int child) 
     74    @Override 
     75        public void addChild(int parent, int child) 
    7376    { 
    7477        if (parent != -1) 
    …… 
    8588    } 
    8689     
    87     public int getParent(int nodeID, int layerID) 
     90    @Override 
     91        public int getParent(int nodeID, int layerID) 
    8892    { 
    8993        Integer parent = parents.get(nodeID); 
    …… 
    9296    } 
    9397     
    94     public String getNodeCaption(int nodeID) 
     98    @Override 
     99        public String getNodeCaption(int nodeID) 
    95100    { 
    96101        String caption = nodeCaptions.get(nodeID); 
    …… 
    105110    } 
    106111     
    107     public String getEdgeLabel(int nodeID) 
     112    @Override 
     113        public String getEdgeLabel(int nodeID) 
    108114    { 
    109115        String label = edgeLabels.get(nodeID); 
    …… 
    118124    } 
    119125     
    120     public int getNodeStatus(int nodeID) 
     126    @Override 
     127        public int getNodeStatus(int nodeID) 
    121128    { 
    122129        Integer st = status.get(nodeID); 
    …… 
    131138    } 
    132139     
    133     public List<Integer> getChildren(int nodeID, int layerID) 
     140    @Override 
     141        public List<Integer> getChildren(int nodeID, int layerID) 
    134142    { 
    135143        //System.err.print("KahinaTree.getChildren(" + nodeID + "," + layerID + ") = "); 
    …… 
    147155    } 
    148156     
    149     public List<Integer> getLeaves() 
     157    @Override 
     158        public List<Integer> getLeaves() 
    150159    { 
    151160        List<Integer> leaves = new LinkedList<Integer>(); 
    …… 
    173182    } 
    174183     
    175     public HashMap<Integer, String> getNodeCaptions() 
     184    @Override 
     185        public Map<Integer, String> getNodeCaptions() 
    176186    { 
    177187        return nodeCaptions; 
    178188    } 
    179189 
    180     public void setNodeCaptions(HashMap<Integer, String> nodeCaptions) 
     190    @Override 
     191        public void setNodeCaptions(Map<Integer, String> nodeCaptions) 
    181192    { 
    182193        this.nodeCaptions = nodeCaptions; 
    183194    } 
    184195 
    185     public HashMap<Integer, String> getEdgeLabels() 
     196    @Override 
     197        public Map<Integer, String> getEdgeLabels() 
    186198    { 
    187199        return edgeLabels; 
    188200    } 
    189201 
    190     public void setEdgeLabels(HashMap<Integer, String> edgeLabels) 
     202    @Override 
     203        public void setEdgeLabels(Map<Integer, String> edgeLabels) 
    191204    { 
    192205        this.edgeLabels = edgeLabels; 
    193206    } 
    194207 
    195     public HashMap<Integer, Integer> getStatus() 
     208    @Override 
     209        public Map<Integer, Integer> getStatus() 
    196210    { 
    197211        return status; 
    198212    } 
    199213 
    200     public void setStatus(HashMap<Integer, Integer> status) 
     214    @Override 
     215        public void setStatus(Map<Integer, Integer> status) 
    201216    { 
    202217        this.status = status; 
    203218    } 
    204219     
    205     public boolean isCollapsed(int nodeID) 
     220    @Override 
     221        public boolean isCollapsed(int nodeID) 
    206222    { 
    207223        return collapsed.contains(nodeID); 
    208224    } 
    209225     
    210     public void collapse(int nodeID) 
     226    @Override 
     227        public void collapse(int nodeID) 
    211228    { 
    212229        if (nodeID != -1) 
    …… 
    216233    } 
    217234     
    218     public void decollapse(int nodeID) 
     235    @Override 
     236        public void decollapse(int nodeID) 
    219237    { 
    220238        collapsed.remove(nodeID); 
    221239    } 
    222240     
    223     public void decollapseAll() 
     241    @Override 
     242        public void decollapseAll() 
    224243    { 
    225244        collapsed = new HashSet<Integer>(); 
    226245    } 
    227246     
    228     public void toggleCollapse(int nodeID) 
     247    @Override 
     248        public void toggleCollapse(int nodeID) 
    229249    { 
    230250        if (!isCollapsed(nodeID)) 
    …… 
    238258    } 
    239259     
    240     public boolean hasCollapsedAncestor(int nodeID) 
     260    @Override 
     261        public boolean hasCollapsedAncestor(int nodeID) 
    241262    { 
    242263        Integer parent = parents.get(nodeID); 
    …… 
    252273    } 
    253274     
    254     public int addNode(String caption, String label, int nodeStatus) 
     275    @Override 
     276        public int addNode(String caption, String label, int nodeStatus) 
    255277    { 
    256278        int nodeID = getNextFreeID(); 
    …… 
    272294    } 
    273295     
    274     public void clear() 
     296    @Override 
     297        public void clear() 
    275298    { 
    276299        rootID = -1; 
    …… 
    322345    } 
    323346     
    324     public static KahinaTree importXML(Document dom) 
    325     { 
    326         KahinaTree m = new KahinaTree(); 
     347    public static KahinaMemTree importXML(Document dom) 
     348    { 
     349        KahinaMemTree m = new KahinaMemTree(); 
    327350        Element treeElement = dom.getDocumentElement();   
    328351        NodeList childNodes = treeElement.getChildNodes(); 
    …… 
    341364    } 
    342365     
    343     private static void importXMLNode(KahinaTree m, Element node, int parentID) 
     366    private static void importXMLNode(KahinaMemTree m, Element node, int parentID) 
    344367    { 
    345368        int nodeID = 0; 

  • kahina/trunk/src/org/kahina/data/tree/KahinaTree.java

    r34 r42  
    11package org.kahina.data.tree; 
    22 
    3 import java.util.ArrayList; 
    4 import java.util.HashMap; 
    5 import java.util.HashSet; 
    6 import java.util.LinkedList; 
    73import java.util.List; 
     4import java.util.Map; 
    85 
    96import org.kahina.core.data.KahinaObject; 
    10 import org.kahina.data.chart.KahinaChart; 
    11 import org.w3c.dom.Document; 
    12 import org.w3c.dom.Element; 
    13 import org.w3c.dom.Node; 
    14 import org.w3c.dom.NodeList; 
    157 
    16 public class KahinaTree extends KahinaObject 
     8public abstract class KahinaTree extends KahinaObject 
    179{ 
    18     static int lastID = 0; 
    19     static String type = "KahinaTree"; 
    20      
    21     //empty tree has rootID = -1 
    22     protected int rootID = -1; 
    23      
    24     //encode properties of individual nodes 
    25     protected HashMap<Integer, Integer> parents; 
    26     protected HashMap<Integer, List<Integer>> children; 
    27     protected HashMap<Integer, String> nodeCaptions; //captions are displayed on the nodes 
    28     protected HashMap<Integer, String> edgeLabels; //labels are displayed on the edges to the parent 
    29     protected HashMap<Integer, Integer> status; //appearance of nodes can be steered by appearance 
    30     protected HashSet<Integer> collapsed; //node collapsing is stored in the model, not in individual views! 
    31      
    32     HashSet<Integer> terminals; //terminals will be displayed on one level 
    33      
    34     //store the ID of the next node that is going to be added 
    35     private int nextID = 0; 
    36     //internal link to the primary model, must sometimes be used for decisions 
    37     protected KahinaTree primaryModel; 
    38      
    39     public KahinaTree() 
    40     { 
    41         super(lastID++); 
    42          
    43         rootID = -1; 
    44          
    45         parents = new HashMap<Integer, Integer>(); 
    46         children = new HashMap<Integer, List<Integer>>(); 
    47         nodeCaptions = new HashMap<Integer, String>(); 
    48         edgeLabels = new HashMap<Integer, String>(); 
    49         status = new HashMap<Integer, Integer>(); 
    50         collapsed = new HashSet<Integer>(); 
    51          
    52         terminals = new HashSet<Integer>(); 
    53          
    54         primaryModel = this; 
    55     } 
    56      
    57     public void setPrimaryModel(KahinaTree primaryModel) 
    58     { 
    59         this.primaryModel = primaryModel; 
    60     } 
    61      
    62     public int getRootID(int layerID) 
    63     { 
    64         return rootID; 
    65     } 
    66      
    67     public void setRootID(int rootID) 
    68     { 
    69         this.rootID = rootID; 
    70     } 
    71      
    72     public void addChild(int parent, int child) 
    73     { 
    74         if (parent != -1) 
    75         { 
    76             List<Integer> childIDs = children.get(parent); 
    77             if (childIDs == null) 
    78             { 
    79                 childIDs = new ArrayList<Integer>(); 
    80                 children.put(parent, childIDs); 
    81             } 
    82             childIDs.add(child); 
    83         } 
    84         parents.put(child, parent); 
    85     } 
    86      
    87     public int getParent(int nodeID, int layerID) 
    88     { 
    89         Integer parent = parents.get(nodeID); 
    90         if (parent == null) return -1; 
    91         return parent; 
    92     } 
    93      
    94     public String getNodeCaption(int nodeID) 
    95     { 
    96         String caption = nodeCaptions.get(nodeID); 
    97         if (caption == null) 
    98         { 
    99             return null; 
    100         } 
    101         else 
    102         { 
    103             return caption; 
    104         } 
    105     } 
    106      
    107     public String getEdgeLabel(int nodeID) 
    108     { 
    109         String label = edgeLabels.get(nodeID); 
    110         if (label == null) 
    111         { 
    112             return ""; 
    113         } 
    114         else 
    115         { 
    116             return label; 
    117         } 
    118     } 
    119      
    120     public int getNodeStatus(int nodeID) 
    121     { 
    122         Integer st = status.get(nodeID); 
    123         if (st == null) 
    124         { 
    125             return 0; 
    126         } 
    127         else 
    128         { 
    129             return st; 
    130         } 
    131     } 
    132      
    133     public List<Integer> getChildren(int nodeID, int layerID) 
    134     { 
    135         //System.err.print("KahinaTree.getChildren(" + nodeID + "," + layerID + ") = "); 
    136         List<Integer> ids = children.get(nodeID); 
    137         if (ids == null) 
    138         { 
    139             //System.err.println("[]"); 
    140             return new ArrayList<Integer>(); 
    141         } 
    142         else 
    143         { 
    144             //System.err.println(ids); 
    145             return ids; 
    146         } 
    147     } 
    148      
    149     public List<Integer> getLeaves() 
    150     { 
    151         List<Integer> leaves = new LinkedList<Integer>(); 
    152         collectLeaves(rootID, leaves); 
    153         return leaves; 
    154     } 
    155      
    156     private void collectLeaves(int nodeID, List<Integer> leaves) 
    157     { 
    158         if (nodeID != -1) 
    159         { 
    160             List<Integer> nodeChildren = children.get(nodeID); 
    161             if (nodeChildren == null) 
    162             { 
    163                 leaves.add(nodeID); 
    164             } 
    165             else 
    166             { 
    167                 for (int child : nodeChildren) 
    168                 { 
    169                     collectLeaves(child, leaves); 
    170                 } 
    171             } 
    172         } 
    173     } 
    174      
    175     public HashMap<Integer, String> getNodeCaptions() 
    176     { 
    177         return nodeCaptions; 
    178     } 
    17910 
    180     public void setNodeCaptions(HashMap<Integer, String> nodeCaptions) 
    181     { 
    182         this.nodeCaptions = nodeCaptions; 
    183     } 
     11       public KahinaTree(int id) 
     12       { 
     13               super(id); 
     14       } 
    18415 
    185     public HashMap<Integer, String> getEdgeLabels() 
    186     { 
    187         return edgeLabels; 
    188     } 
     16        public abstract void clear(); 
    18917 
    190     public void setEdgeLabels(HashMap<Integer, String> edgeLabels) 
    191     { 
    192         this.edgeLabels = edgeLabels; 
    193     } 
     18        public abstract int addNode(String caption, String label, int nodeStatus); 
    19419 
    195     public HashMap<Integer, Integer> getStatus() 
    196     { 
    197         return status; 
    198     } 
     20        public abstract boolean hasCollapsedAncestor(int nodeID); 
    19921 
    200     public void setStatus(HashMap<Integer, Integer> status) 
    201     { 
    202         this.status = status; 
    203     } 
    204      
    205     public boolean isCollapsed(int nodeID) 
    206     { 
    207         return collapsed.contains(nodeID); 
    208     } 
    209      
    210     public void collapse(int nodeID) 
    211     { 
    212         if (nodeID != -1) 
    213         { 
    214             collapsed.add(nodeID); 
    215         } 
    216     } 
    217      
    218     public void decollapse(int nodeID) 
    219     { 
    220         collapsed.remove(nodeID); 
    221     } 
    222      
    223     public void decollapseAll() 
    224     { 
    225         collapsed = new HashSet<Integer>(); 
    226     } 
    227      
    228     public void toggleCollapse(int nodeID) 
    229     { 
    230         if (!isCollapsed(nodeID)) 
    231         { 
    232             collapse(nodeID); 
    233         } 
    234         else 
    235         { 
    236             decollapse(nodeID); 
    237         } 
    238     } 
    239      
    240     public boolean hasCollapsedAncestor(int nodeID) 
    241     { 
    242         Integer parent = parents.get(nodeID); 
    243         while (parent != null) 
    244         { 
    245             if (isCollapsed(parent)) 
    246             { 
    247                 return true; 
    248             } 
    249             parent = parents.get(parent); 
    250         } 
    251         return false; 
    252     } 
    253      
    254     public int addNode(String caption, String label, int nodeStatus) 
    255     { 
    256         int nodeID = getNextFreeID(); 
    257         nodeCaptions.put(nodeID, caption); 
    258         edgeLabels.put(nodeID, label); 
    259         status.put(nodeID,nodeStatus); 
    260         return nodeID; 
    261     } 
     22        public abstract void toggleCollapse(int nodeID); 
    26223 
    263     protected int getNextFreeID() 
    264     { 
    265         int nextIDHyp = nextID; 
    266         while (parents.get(nextIDHyp) != null) 
    267         { 
    268             nextIDHyp++; 
    269         } 
    270         nextID = nextIDHyp + 1; 
    271         return nextIDHyp; 
    272     } 
    273      
    274     public void clear() 
    275     { 
    276         rootID = -1; 
    277          
    278         parents = new HashMap<Integer, Integer>(); 
    279         children = new HashMap<Integer, List<Integer>>(); 
    280         nodeCaptions = new HashMap<Integer, String>(); 
    281         edgeLabels = new HashMap<Integer, String>(); 
    282         status = new HashMap<Integer, Integer>(); 
    283         collapsed = new HashSet<Integer>(); 
    284          
    285         terminals = new HashSet<Integer>(); 
    286          
    287         primaryModel = this; 
    288          
    289         nextID = 0; 
    290     } 
    291      
    292     public String exportXML() 
    293     { 
    294         StringBuilder b = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"); 
    295         b.append("<kahinaTree>\n"); 
    296         if (rootID != -1) 
    297         { 
    298             exportXML(b, rootID, 2); 
    299         } 
    300         b.append("</kahinaTree>\n"); 
    301         return b.toString(); 
    302     } 
    303      
    304     private void exportXML(StringBuilder b, int node, int depth) 
    305     { 
    306         createSpace(b, depth); 
    307         b.append("<node id=\"" + node + "\" caption=\"" + getNodeCaption(node) + "\" label=\"" + getEdgeLabel(node) + "\" status=\"" + getNodeStatus(node) + "\">\n"); 
    308         for (int child : getChildren(node, 0)) 
    309         { 
    310             exportXML(b, child, depth + 2); 
    311         } 
    312         createSpace(b, depth); 
    313         b.append("</node>\n"); 
    314     } 
    315      
    316     private void createSpace(StringBuilder b, int amount) 
    317     { 
    318         for (int i = 0; i < amount; i++) 
    319         { 
    320             b.append(' '); 
    321         } 
    322     } 
    323      
    324     public static KahinaTree importXML(Document dom) 
    325     { 
    326         KahinaTree m = new KahinaTree(); 
    327         Element treeElement = dom.getDocumentElement();   
    328         NodeList childNodes = treeElement.getChildNodes(); 
    329         for (int i = 0; i < childNodes.getLength(); i++) 
    330         { 
    331             Node n = childNodes.item(i); 
    332             if (n.getNodeName().equals("node")) 
    333             { 
    334                 importXMLNode(m, (Element) n, -1); 
    335                 //TODO: a little risky, root node could be assigned another ID 
    336                 m.rootID = 0; 
    337                 break; 
    338             } 
    339         } 
    340         return m; 
    341     } 
    342      
    343     private static void importXMLNode(KahinaTree m, Element node, int parentID) 
    344     { 
    345         int nodeID = 0; 
    346         if (node.getAttribute("id").length() > 0) 
    347         { 
    348             nodeID = Integer.parseInt(node.getAttribute("id")); 
    349         } 
    350         else 
    351         { 
    352             nodeID = m.getNextFreeID(); 
    353         } 
    354         m.nodeCaptions.put(nodeID, node.getAttribute("caption")); 
    355         m.edgeLabels.put(nodeID, node.getAttribute("label")); 
    356         if (node.getAttribute("status").length() > 0) 
    357         { 
    358             m.status.put(nodeID, Integer.parseInt(node.getAttribute("status"))); 
    359         } 
    360         m.addChild(parentID, nodeID); 
    361         //go through children recursively 
    362         NodeList childNodes = node.getChildNodes(); 
    363         for (int i = 0; i < childNodes.getLength(); i++) 
    364         { 
    365             Node n = childNodes.item(i); 
    366             if (n.getNodeName().equals("node")) 
    367             { 
    368                 importXMLNode(m, (Element) n, nodeID); 
    369             } 
    370         } 
    371     } 
     24        public abstract void decollapseAll(); 
     25 
     26        public abstract void decollapse(int nodeID); 
     27 
     28        public abstract void collapse(int nodeID); 
     29 
     30        public abstract boolean isCollapsed(int nodeID); 
     31 
     32        public abstract void setStatus(Map<Integer, Integer> status); 
     33 
     34        public abstract Map<Integer, Integer> getStatus(); 
     35 
     36        public abstract void setEdgeLabels(Map<Integer, String> edgeLabels); 
     37 
     38        public abstract Map<Integer, String> getEdgeLabels(); 
     39 
     40        public abstract void setNodeCaptions(Map<Integer, String> nodeCaptions); 
     41 
     42        public abstract Map<Integer, String> getNodeCaptions(); 
     43 
     44        public abstract List<Integer> getLeaves(); 
     45 
     46        public abstract List<Integer> getChildren(int nodeID, int layerID); 
     47 
     48        public abstract int getNodeStatus(int nodeID); 
     49 
     50        public abstract String getEdgeLabel(int nodeID); 
     51 
     52        public abstract String getNodeCaption(int nodeID); 
     53 
     54        public abstract int getParent(int nodeID, int layerID); 
     55 
     56        public abstract void addChild(int parent, int child); 
     57 
     58        public abstract void setRootID(int rootID); 
     59 
     60        public abstract int getRootID(int layerID); 
     61 
     62        public abstract void setPrimaryModel(KahinaTree primaryModel); 
     63 
    37264}