Changeset 50

Show
Ignore:
Timestamp:
02/22/10 02:02:40 (2 years ago)
Author:
ke
Message:

Refactored tree classes, completed KahinaDbTree? (not tested yet).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • kahina/trunk/src/org/kahina/core/KahinaState.java

    r46 r50  
    11package org.kahina.core; 
    22 
    3 import org.kahina.data.tree.KahinaMemTree; 
    43import org.kahina.data.tree.KahinaTree; 
    54 
    …… 
    1716{       
    1817    //the data structures that a kahina state always contains 
    19     KahinaMemTree stepTree; 
     18    KahinaTree stepTree; 
    2019    KahinaTree secondaryStepTree;  
    2120} 

  • kahina/trunk/src/org/kahina/core/data/DbDataManager.java

    r49 r50  
    5151 
    5252        /** 
    53          * Registers a new data type with a 
    54          * {@link LightweightKahinaObjectDbDataStore}. 
    55          *  
    56          * @param type 
    57          *            Must be a subclass of {@link LightweightKahinaObject}. 
     53         * Registers a new data type. If the type is a subclass of 
     54         * {@link LightweightKahinaObject}, objects of this type will be stored in 
     55         * the database, otherwise in memory. 
    5856         */ 
    5957        @Override 

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

    r48 r50  
    11package org.kahina.data.tree; 
    22 
     3import java.sql.PreparedStatement; 
     4import java.sql.SQLException; 
     5import java.util.Collections; 
    36import java.util.List; 
    47 
     8import org.kahina.core.KahinaException; 
    59import org.kahina.io.database.DatabaseHandler; 
    610 
    …… 
    1519        private static final String NODE_TABLE_NAME = TABLE_NAME_PREFIX + "nodes"; 
    1620 
    17         private static final String EDGE_TABLE_NAME = TABLE_NAME_PREFIX + "edges"; 
    18  
    1921        private DatabaseHandler db; 
    20          
     22 
     23        private PreparedStatement addNodeStatement; 
     24 
     25        private PreparedStatement addEdgeStatement; 
     26 
     27        private PreparedStatement addLayerInformationStatement; 
     28 
     29        private PreparedStatement getRealParentStatement; 
     30 
     31        private PreparedStatement getVirtualParentStatement; 
     32 
     33        private PreparedStatement getLayerStatement; 
     34 
     35        private PreparedStatement clearStatement; 
     36 
     37        private PreparedStatement collapseStatement; 
     38 
     39        private PreparedStatement decollapseStatement; 
     40 
     41        private PreparedStatement decollapseAllStatement; 
     42 
     43        private PreparedStatement getRealChildrenStatement; 
     44 
     45        private PreparedStatement getVirtualChildrenStatement; 
     46 
     47        private PreparedStatement getEdgeLabelStatement; 
     48 
     49        private PreparedStatement getNodeCaptionStatement; 
     50 
     51        private PreparedStatement getNodeStatusStatement; 
     52 
     53        private PreparedStatement getRootStatement; 
     54 
     55        private PreparedStatement isCollapsedStatement; 
     56 
     57        private PreparedStatement getSizeStatement; 
     58 
     59        private int nextID; 
     60 
    2161        public KahinaDbTree(DatabaseHandler db) 
    2262        { 
    …… 
    3070                createTablesIfNecessary(); 
    3171                prepareStatements(); 
     72                nextID = 0; 
    3273        } 
    3374 
    …… 
    3677                if (!db.isRegistered(CLIENT_ID)) 
    3778                { 
    38                         db 
    39                                         .execute("CREATE TABLE " 
    40                                                        + NODE_TABLE_NAME 
    41                                                        + " (id INT, nodeCaption LONG VARCHAR, edgeLabel LONG VARCHAR, collapsed TINYINT(1), terminal TINYINT(1), PRIMARY KEY id)"); 
    42                         db 
    43                                         .execute("CREATE TABLE " 
    44                                                        + EDGE_TABLE_NAME 
    45                                                        + " (child_id INT, parent_id INT, layer INT, INDEX child_id (child_id), INDEX parent_id (parent_id), INDEX layer (layer))"); 
    46                 } 
    47         } 
    48          
     79                        db.execute("CREATE TABLE " + NODE_TABLE_NAME + " (id INT, " 
     80                                        + "tree INT, " + "nodeCaption LONG VARCHAR," 
     81                                        + " edgeLabel LONG VARCHAR," + " collapsed TINYINT(1)," 
     82                                        + " realParent INT," + " layer INT," 
     83                                       + " virtualParent INT," + " PRIMARY KEY (id, tree) " 
     84                                        + "INDEX realParent (realParent), " 
     85                                        + "INDEX layer (layer), " 
     86                                        + "INDEX virtualParent (virtualParent))"); 
     87                } 
     88        } 
     89 
    4990        private void prepareStatements() 
    5091        { 
    51                 // TODO 
     92                int treeID = getID(); 
     93                addNodeStatement = db.prepareStatement("INSERT INTO " + NODE_TABLE_NAME 
     94                                + " (id, tree, nodeCaption, edgeLabel) VALUES (?, " + treeID 
     95                                + ", ?, ?)"); 
     96                addEdgeStatement = db.prepareStatement("UPDATE " + NODE_TABLE_NAME 
     97                                + " SET realParent = ? WHERE id = ? AND tree = " + treeID); 
     98                addLayerInformationStatement = db.prepareStatement("UPDATE " 
     99                                + NODE_TABLE_NAME 
     100                                + " SET layer = ?, virtualParent = ? WHERE id = ? AND tree = " 
     101                                + treeID); 
     102                getRealParentStatement = db.prepareStatement("SELECT realParent FROM " 
     103                                + NODE_TABLE_NAME + " WHERE id = ? AND tree = " + treeID); 
     104                getVirtualParentStatement = db 
     105                                .prepareStatement("SELECT virtualParent FROM " 
     106                                                + NODE_TABLE_NAME + " WHERE id = ? AND tree = " 
     107                                                + treeID); 
     108                clearStatement = db.prepareStatement("DELETE FROM " + NODE_TABLE_NAME 
     109                                + " WHERE tree = " + treeID); 
     110                collapseStatement = db.prepareStatement("UPDATE " + NODE_TABLE_NAME 
     111                                + " SET collapsed = 1 WHERE id = ? AND tree = " + treeID); 
     112                decollapseStatement = db.prepareStatement("UPDATE " + NODE_TABLE_NAME 
     113                                + " SET collapsed = 0 WHERE id = ? AND tree = " + treeID); 
     114                decollapseAllStatement = db 
     115                                .prepareStatement("UPDATE " + NODE_TABLE_NAME 
     116                                                + " SET collapsed = 0 WHERE tree = " + treeID); 
     117                getRealChildrenStatement = db.prepareStatement("SELECT id FROM " 
     118                                + NODE_TABLE_NAME + " WHERE realParent = ? AND tree = " 
     119                                + treeID); 
     120                getVirtualChildrenStatement = db.prepareStatement("SELECT id FROM " 
     121                                + NODE_TABLE_NAME + " WHERE virtualParent = ? AND tree = " 
     122                                + treeID); 
     123                getEdgeLabelStatement = db.prepareStatement("SELECT edgeLabel FROM " 
     124                                + NODE_TABLE_NAME + " WHERE id = ? AND tree = " + treeID); 
     125                getNodeCaptionStatement = db 
     126                                .prepareStatement("SELECT nodeCaption FROM " + NODE_TABLE_NAME 
     127                                                + " WHERE id = ? AND tree = " + treeID); 
     128                getRootStatement = db.prepareStatement("SELECT id FROM " 
     129                                + NODE_TABLE_NAME + " WHERE realParent IS NULL AND tree = " 
     130                                + treeID); 
     131                isCollapsedStatement = db.prepareStatement("SELECT collapsed FROM " 
     132                                + NODE_TABLE_NAME + " WHERE id = ? AND tree = " + treeID); 
     133                getSizeStatement = db.prepareStatement("SELECT COUNT(*) FROM " 
     134                                + NODE_TABLE_NAME + " WHERE tree = " + treeID); 
     135        } 
     136 
     137        @Override 
     138        public int addNode(String caption, String label, int nodeStatus) 
     139        { 
     140                int id = nextID++; 
     141                try 
     142                { 
     143                        addNodeStatement.setInt(1, id); 
     144                        addNodeStatement.setString(2, caption); 
     145                        addNodeStatement.setString(3, label); 
     146                        addNodeStatement.execute(); 
     147                } catch (SQLException e) 
     148                { 
     149                        throw new KahinaException("SQL error.", e); 
     150                } 
     151                return id; 
    52152        } 
    53153 
    …… 
    55155        public void addChild(int parent, int child) 
    56156        { 
    57                 // add 
    58                 // nach oben gehen und jedem 
    59         } 
    60  
    61         @Override 
    62         public int addNode(String caption, String label, int nodeStatus) 
    63         { 
    64                 // TODO Auto-generated method stub 
    65                 return 0; 
     157                try 
     158                { 
     159                        addEdgeStatement.setInt(1, parent); 
     160                        addEdgeStatement.setInt(2, child); 
     161                        addEdgeStatement.execute(); 
     162                } catch (SQLException e) 
     163                { 
     164                        throw new KahinaException("SQL error.", e); 
     165                } 
     166                int layer = decider.decideOnLayer(child, this); 
     167                int virtualParent = parent; 
     168                while (getLayer(virtualParent) > layer) 
     169                { 
     170                        virtualParent = getVirtualParent(virtualParent); 
     171                } 
     172                try 
     173                { 
     174                        addLayerInformationStatement.setInt(1, layer); 
     175                        addLayerInformationStatement.setInt(2, virtualParent); 
     176                        addLayerInformationStatement.setInt(3, child); 
     177                        addLayerInformationStatement.execute(); 
     178                } catch (SQLException e) 
     179                { 
     180                        throw new KahinaException("SQL error.", e); 
     181                } 
     182        } 
     183 
     184        @Override 
     185        public int getParent(int nodeID) 
     186        { 
     187                try 
     188                { 
     189                        getRealParentStatement.setInt(1, nodeID); 
     190                } catch (SQLException e) 
     191                { 
     192                        throw new KahinaException("SQL error.", e); 
     193                } 
     194                return db.queryInteger(getRealParentStatement, -1); 
     195        } 
     196 
     197        private int getVirtualParent(int nodeID) 
     198        { 
     199                try 
     200                { 
     201                        getVirtualParentStatement.setInt(1, nodeID); 
     202                } catch (SQLException e) 
     203                { 
     204                        throw new KahinaException("SQL error.", e); 
     205                } 
     206                return db.queryInteger(getVirtualParentStatement, -1); 
     207        } 
     208 
     209        private int getLayer(int nodeID) 
     210        { 
     211                try 
     212                { 
     213                        getLayerStatement.setInt(1, nodeID); 
     214                } catch (SQLException e) 
     215                { 
     216                        throw new KahinaException("SQL error.", e); 
     217                } 
     218                return db.queryInteger(getLayerStatement, 0); 
    66219        } 
    67220 
    …… 
    69222        public void clear() 
    70223        { 
    71                 // TODO Auto-generated method stub 
    72  
     224                db.execute(clearStatement); 
    73225        } 
    74226 
    …… 
    76228        public void collapse(int nodeID) 
    77229        { 
    78                 // TODO Auto-generated method stub 
    79  
     230                try 
     231                { 
     232                        collapseStatement.setInt(1, nodeID); 
     233                        collapseStatement.execute(); 
     234                } catch (SQLException e) 
     235                { 
     236                        throw new KahinaException("SQL error.", e); 
     237                } 
    80238        } 
    81239 
    …… 
    83241        public void decollapse(int nodeID) 
    84242        { 
    85                 // TODO Auto-generated method stub 
    86  
     243                try 
     244                { 
     245                        decollapseStatement.setInt(1, nodeID); 
     246                        decollapseStatement.execute(); 
     247                } catch (SQLException e) 
     248                { 
     249                        throw new KahinaException("SQL error.", e); 
     250                } 
    87251        } 
    88252 
    …… 
    90254        public void decollapseAll() 
    91255        { 
    92                 // TODO Auto-generated method stub 
    93  
    94         } 
    95  
    96         @Override 
    97         public List<Integer> getChildren(int nodeID, int layerID) 
    98         { 
    99                 // TODO Auto-generated method stub 
    100                 return null; 
     256                db.execute(decollapseAllStatement); 
     257        } 
     258 
     259        @Override 
     260        public List<Integer> getChildren(int nodeID, int layer) 
     261        { 
     262                int nodeLayer = getLayer(nodeID); 
     263                if (layer == nodeLayer) 
     264                { 
     265                        // the most common case, for which we have precalculated the virtual 
     266                        // children 
     267                        return getVirtualChildren(nodeID); 
     268                } 
     269                if (nodeID == getRootID(layer) || nodeLayer >= layer) 
     270                { 
     271                        // usually only the case for the root of a partial tree 
     272                        List<Integer> frontLine = getRealChildren(nodeID); 
     273                        for (int i = 0; i < frontLine.size();) 
     274                        { 
     275                                int child = frontLine.get(i); 
     276                                if (getLayer(child) > layer) 
     277                                { 
     278                                        frontLine.remove(i); 
     279                                        frontLine.addAll(i, getRealChildren(child)); 
     280                                } else 
     281                                { 
     282                                        i++; 
     283                                } 
     284                        } 
     285                        return frontLine; 
     286                } 
     287                // When we have reached a "cornerstone", pretend it's a leaf: 
     288                return Collections.emptyList(); 
     289        } 
     290 
     291        private List<Integer> getRealChildren(int nodeID) 
     292        { 
     293                try 
     294                { 
     295                        getRealChildrenStatement.setInt(1, nodeID); 
     296                } catch (SQLException e) 
     297                { 
     298                        throw new KahinaException("SQL error.", e); 
     299                } 
     300                return db.queryIntList(getRealChildrenStatement); 
     301        } 
     302 
     303        private List<Integer> getVirtualChildren(int nodeID) 
     304        { 
     305                try 
     306                { 
     307                        getVirtualChildrenStatement.setInt(1, nodeID); 
     308                } catch (SQLException e) 
     309                { 
     310                        throw new KahinaException("SQL error.", e); 
     311                } 
     312                return db.queryIntList(getVirtualChildrenStatement); 
    101313        } 
    102314 
    …… 
    104316        public String getEdgeLabel(int nodeID) 
    105317        { 
    106                 // TODO Auto-generated method stub 
    107                 return null; 
    108         } 
    109  
    110         @Override 
    111         public List<Integer> getLeaves() 
    112         { 
    113                 // TODO Auto-generated method stub 
    114                 return null; 
     318                try 
     319                { 
     320                        getEdgeLabelStatement.setInt(1, nodeID); 
     321                } catch (SQLException e) 
     322                { 
     323                        throw new KahinaException("SQL error.", e); 
     324                } 
     325                return db.queryString(getEdgeLabelStatement, ""); 
     326        } 
     327 
     328        @Override 
     329        protected void collectLeaves(int nodeID, List<Integer> leaves) 
     330        { 
     331                List<Integer> children = getRealChildren(nodeID); 
     332                if (children.isEmpty()) 
     333                { 
     334                        leaves.add(nodeID); 
     335                } else 
     336                { 
     337                        for (int child : children) 
     338                        { 
     339                                collectLeaves(child, leaves); 
     340                        } 
     341                } 
    115342        } 
    116343 
    …… 
    118345        public String getNodeCaption(int nodeID) 
    119346        { 
    120                 // TODO Auto-generated method stub 
    121                 return null; 
     347                try 
     348                { 
     349                        getNodeCaptionStatement.setInt(1, nodeID); 
     350                } catch (SQLException e) 
     351                { 
     352                        throw new KahinaException("SQL error.", e); 
     353                } 
     354                return db.queryString(getNodeCaptionStatement, ""); 
    122355        } 
    123356 
    …… 
    125358        public int getNodeStatus(int nodeID) 
    126359        { 
    127                 // TODO Auto-generated method stub 
    128                 return 0; 
    129         } 
    130  
    131         @Override 
    132         public int getParent(int nodeID, int layerID) 
    133         { 
    134                 // TODO Auto-generated method stub 
    135                 return 0; 
     360                try 
     361                { 
     362                        getNodeStatusStatement.setInt(1, nodeID); 
     363                } catch (SQLException e) 
     364                { 
     365                        throw new KahinaException("SQL error.", e); 
     366                } 
     367                return db.queryInteger(getNodeStatusStatement, 0); 
     368        } 
     369 
     370        @Override 
     371        public int getParent(int nodeID, int layer) 
     372        { 
     373                if (nodeID == getRootID(layer)) 
     374                { 
     375                        return -1; 
     376                } 
     377                if (getLayer(nodeID) == layer) 
     378                { 
     379                        return getVirtualParent(nodeID); 
     380                } 
     381                int result = getParent(nodeID); 
     382                while (getLayer(result) > layer) 
     383                { 
     384                        result = getParent(result); 
     385                } 
     386                return result; 
    136387        } 
    137388 
    …… 
    139390        public int getRootID() 
    140391        { 
    141                 // TODO Auto-generated method stub 
    142                return 0; 
    143         } 
    144  
    145         @Override 
    146         public int getRootID(int layerID) 
    147         { 
    148                 // TODO Auto-generated method stub 
    149                 return 0; 
    150         } 
    151  
    152         @Override 
    153         public boolean hasCollapsedAncestor(int nodeID) 
    154         { 
    155                 // TODO Auto-generated method stub 
    156                 return false; 
     392                return db.queryInteger(getRootStatement, -1); 
     393        } 
     394 
     395        @Override 
     396        public int getRootID(int layer) 
     397        { 
     398               if (layer == 0) 
     399                { 
     400                       return getRootID(); 
     401               } 
     402                int result = getReferenceNode(); 
     403               while (getLayer(result) >= layer) 
     404               { 
     405                       result = getParent(result); 
     406                } 
     407                return result; 
    157408        } 
    158409 
    …… 
    160411        public boolean isCollapsed(int nodeID) 
    161412        { 
    162                 // TODO Auto-generated method stub 
    163                 return false; 
    164         } 
    165  
    166         @Override 
    167         public void setPrimaryModel(KahinaTree primaryModel) 
    168         { 
    169                 // TODO Auto-generated method stub 
    170  
    171         } 
    172  
    173         @Override 
    174         public void setRootID(int rootID) 
    175         { 
    176                 // TODO Auto-generated method stub 
    177  
    178         } 
    179  
    180         @Override 
    181         public void toggleCollapse(int nodeID) 
    182         { 
    183                 // TODO Auto-generated method stub 
    184  
     413                try 
     414                { 
     415                        isCollapsedStatement.setInt(1, nodeID); 
     416                } catch (SQLException e) 
     417                { 
     418                        throw new KahinaException("SQL error.", e); 
     419                } 
     420                int result = db.queryInteger(isCollapsedStatement, 0); 
     421                return result == 1; 
    185422        } 
    186423 
    …… 
    188425        public int getSize() 
    189426        { 
    190                 // TODO Auto-generated method stub 
    191                 return 0; 
     427                return db.queryInteger(getSizeStatement, 0); 
    192428        } 
    193429 

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

    r47 r50  
    1111public class KahinaMemTree extends KahinaUnlayeredMemTree 
    1212{    
    13     //reference node should always be the same across views, so store it here 
    14     int referenceNode; 
    15      
    1613    public KahinaMemTree() 
    1714    { 
    …… 
    2219    { 
    2320        super(decider); 
    24         referenceNode = super.getRootID(0); 
     21        setReferenceNode(super.getRootID(0)); 
    2522    }  
    2623     
    27     public int getReferenceNode() 
    28     { 
    29         return referenceNode; 
    30     } 
    31  
    32     public void setReferenceNode(int referenceNode) 
    33     { 
    34         this.referenceNode = referenceNode; 
    35     } 
    36      
    37     public int getRootID(int layerID) 
     24    @Override 
     25        public int getRootID(int layerID) 
    3826    { 
    3927        if (layerID == 0) return super.getRootID(0); 
    40         int rootID = referenceNode; 
     28        int rootID = getReferenceNode(); 
    4129        while (decider.decideOnLayer(rootID, this) >= layerID) 
    4230        { 
    …… 
    5038     * layerID. 
    5139     */ 
    52     public int getParent(int nodeID, int layerID) 
     40    @Override 
     41        public int getParent(int nodeID, int layerID) 
    5342    { 
    5443        if (nodeID == getRootID(layerID)) return -1; 
    …… 
    6554     * Returns those descendants of nodeID whose layer is lower than or equals 
    6655     * layerID and which are not dominated by any other such descendant - but 
    67      * only if the layer of nodeID is greater than or equals layerID (otherwise 
    68      * returns the empty list). 
     56     * only if the layer of nodeID is greater than or equals layerID OR nodeID 
     57     * is the root of the tree fragment currently being drawn as indicated by 
     58     * referenceNode (otherwise returns the empty list). 
    6959     */ 
    70     public List<Integer> getChildren(int nodeID, int layerID) 
     60    @Override 
     61        public List<Integer> getChildren(int nodeID, int layerID) 
    7162    { 
    7263        //System.err.print("KahinaLayeredTree.getChildren(" + nodeID + "," + layerID + ") = "); 
    …… 
    9990    } 
    10091     
    101     public static KahinaMemTree importXML(Document dom) 
     92    public static KahinaTree importXML(Document dom) 
    10293    { 
    10394        KahinaMemTree m = new KahinaMemTree(); 
    …… 
    111102                importXMLNode(m, (Element) n, -1); 
    112103                //TODO: a little risky, root node could be assigned another ID 
    113                 m.rootID = 0; 
     104                m.setRootID(0); 
    114105                break; 
    115106            } 

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

    r48 r50  
    11package org.kahina.data.tree; 
    22 
     3import java.util.LinkedList; 
    34import java.util.List; 
    4 import java.util.Map; 
    55 
    66import org.kahina.core.data.KahinaObject; 
    …… 
    1313 
    1414        private KahinaTree primaryModel; 
     15 
     16        private int referenceNode; 
     17 
     18        private int rootID; 
    1519 
    1620        public KahinaTree(LayerDecider decider) 
    …… 
    2832        public void clear() 
    2933        { 
    30                 setPrimaryModel(this); 
     34                primaryModel = this; 
     35                rootID = -1; 
    3136        } 
    3237 
    3338        public abstract int addNode(String caption, String label, int nodeStatus); 
    34  
    35         public abstract boolean hasCollapsedAncestor(int nodeID); 
    36  
    37         public abstract void toggleCollapse(int nodeID); 
    3839 
    3940        public abstract void decollapseAll(); 
    …… 
    4445 
    4546        public abstract boolean isCollapsed(int nodeID); 
     47     
     48        public List<Integer> getLeaves() 
     49    { 
     50        List<Integer> leaves = new LinkedList<Integer>(); 
     51        collectLeaves(getRootID(), leaves); 
     52        return leaves; 
     53    } 
     54         
     55        protected abstract void collectLeaves(int nodeID, List<Integer> leaves); 
    4656 
    47         public abstract List<Integer> getLeaves(); 
    48  
    49         public abstract List<Integer> getChildren(int nodeID, int layerID); 
     57        public abstract List<Integer> getChildren(int nodeID, int layer); 
    5058 
    5159        public abstract int getNodeStatus(int nodeID); 
    …… 
    5563        public abstract String getNodeCaption(int nodeID); 
    5664 
    57         public abstract int getParent(int nodeID, int layerID); 
     65        public abstract int getParent(int nodeID, int layer); 
    5866 
    5967        public abstract void addChild(int parent, int child); 
    6068 
    61         public abstract void setRootID(int rootID); 
    62          
    63         public abstract int getRootID(); 
    64  
    65         public abstract int getRootID(int layerID); 
     69        public abstract int getRootID(int layer); 
    6670         
    6771        public abstract int getSize(); 
    …… 
    109113        } 
    110114 
     115        public int getReferenceNode() 
     116        { 
     117            return referenceNode; 
     118        } 
     119 
     120        public void setReferenceNode(int referenceNode) 
     121        { 
     122            this.referenceNode = referenceNode; 
     123        } 
     124 
     125        public abstract int getParent(int nodeID); 
     126 
     127        public boolean hasCollapsedAncestor(int nodeID) 
     128        { 
     129            int parent = getParent(nodeID); 
     130            while (parent != -1) 
     131            { 
     132                if (isCollapsed(parent)) 
     133                { 
     134                    return true; 
     135                } 
     136                parent = getParent(parent); 
     137            } 
     138            return false; 
     139        } 
     140 
     141        public int getRootID() 
     142        { 
     143                return rootID; 
     144        } 
     145 
     146        public void setRootID(int rootID) 
     147        { 
     148            this.rootID = rootID; 
     149        } 
     150 
     151        public void toggleCollapse(int nodeID) 
     152        { 
     153            if (!isCollapsed(nodeID)) 
     154            { 
     155                collapse(nodeID); 
     156            } 
     157            else 
     158            { 
     159                decollapse(nodeID); 
     160            } 
     161        } 
     162 
    111163} 

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

    r48 r50  
    22 
    33import java.util.ArrayList; 
     4import java.util.Collections; 
    45import java.util.HashMap; 
    56import java.util.HashSet; 
    …… 
    1920public class KahinaUnlayeredMemTree extends KahinaTree 
    2021{     
    21     //empty tree has rootID = -1 
    22     protected int rootID = -1; 
    23      
    2422    //encode properties of individual nodes 
    2523    protected Map<Integer, Integer> parents; 
    …… 
    3028    protected Set<Integer> collapsed; //node collapsing is stored in the model, not in individual views! 
    3129     
    32     HashSet<Integer> terminals; //terminals will be displayed on one level 
    33      
    3430    //store the ID of the next node that is going to be added 
    3531    private int nextID = 0; 
    …… 
    4238    {         
    4339        super(decider); 
    44         rootID = -1; 
     40         
     41        parents = new HashMap<Integer, Integer>(); 
     42        children = new HashMap<Integer, List<Integer>>(); 
     43        nodeCaptions = new HashMap<Integer, String>(); 
     44        edgeLabels = new HashMap<Integer, String>(); 
     45        status = new HashMap<Integer, Integer>(); 
     46        collapsed = new HashSet<Integer>(); 
     47    } 
     48     
     49    @Override 
     50        public int getRootID(int layerID) 
     51    { 
     52        return getRootID(); 
     53    } 
     54     
     55    @Override 
     56        public void addChild(int parent, int child) 
     57    { 
     58        if (parent != -1) 
     59        { 
     60            List<Integer> childIDs = children.get(parent); 
     61            if (childIDs == null) 
     62            { 
     63                childIDs = new ArrayList<Integer>(); 
     64                children.put(parent, childIDs); 
     65            } 
     66            childIDs.add(child); 
     67        } 
     68        parents.put(child, parent); 
     69    } 
     70     
     71    @Override 
     72        public int getParent(int nodeID, int layerID) 
     73    { 
     74        return getParent(nodeID); 
     75    } 
     76     
     77    @Override 
     78    public int getParent(int nodeID) 
     79    { 
     80        Integer parent = parents.get(nodeID); 
     81        if (parent == null) return -1; 
     82        return parent; 
     83    } 
     84     
     85    @Override 
     86        public String getNodeCaption(int nodeID) 
     87    { 
     88        String caption = nodeCaptions.get(nodeID); 
     89        if (caption == null) 
     90        { 
     91            return null; 
     92        } 
     93        else 
     94        { 
     95            return caption; 
     96        } 
     97    } 
     98     
     99    @Override 
     100        public String getEdgeLabel(int nodeID) 
     101    { 
     102        String label = edgeLabels.get(nodeID); 
     103        if (label == null) 
     104        { 
     105            return ""; 
     106        } 
     107        else 
     108        { 
     109            return label; 
     110        } 
     111    } 
     112     
     113    @Override 
     114        public int getNodeStatus(int nodeID) 
     115    { 
     116        Integer st = status.get(nodeID); 
     117        if (st == null) 
     118        { 
     119            return 0; 
     120        } 
     121        else 
     122        { 
     123            return st; 
     124        } 
     125    } 
     126     
     127    @Override 
     128        public List<Integer> getChildren(int nodeID, int layerID) 
     129    { 
     130        //System.err.print("KahinaTree.getChildren(" + nodeID + "," + layerID + ") = "); 
     131        List<Integer> ids = children.get(nodeID); 
     132        if (ids == null) 
     133        { 
     134            //System.err.println("[]"); 
     135            return Collections.emptyList(); 
     136        } 
     137        else 
     138        { 
     139            //System.err.println(ids); 
     140            return Collections.unmodifiableList(ids); 
     141        } 
     142    } 
     143     
     144    public List<Integer> getLeaves() 
     145    { 
     146        List<Integer> leaves = new LinkedList<Integer>(); 
     147        collectLeaves(getRootID(), leaves); 
     148        return leaves; 
     149    } 
     150     
     151    @Override 
     152    protected void collectLeaves(int nodeID, List<Integer> leaves) 
     153    { 
     154        if (nodeID != -1) 
     155        { 
     156            List<Integer> nodeChildren = children.get(nodeID); 
     157            if (nodeChildren == null) 
     158            { 
     159                leaves.add(nodeID); 
     160            } 
     161            else 
     162            { 
     163                for (int child : nodeChildren) 
     164                { 
     165                    collectLeaves(child, leaves); 
     166                } 
     167            } 
     168        } 
     169    } 
     170     
     171    @Override 
     172        public boolean isCollapsed(int nodeID) 
     173    { 
     174        return collapsed.contains(nodeID); 
     175    } 
     176     
     177    @Override 
     178        public void collapse(int nodeID) 
     179    { 
     180        if (nodeID != -1) 
     181        { 
     182            collapsed.add(nodeID); 
     183        } 
     184    } 
     185     
     186    @Override 
     187        public void decollapse(int nodeID) 
     188    { 
     189        collapsed.remove(nodeID); 
     190    } 
     191     
     192    @Override 
     193        public void decollapseAll() 
     194    { 
     195        collapsed = new HashSet<Integer>(); 
     196    } 
     197     
     198        @Override 
     199        public int addNode(String caption, String label, int nodeStatus) 
     200    { 
     201        int nodeID = getNextFreeID(); 
     202        nodeCaptions.put(nodeID, caption); 
     203        edgeLabels.put(nodeID, label); 
     204        status.put(nodeID,nodeStatus); 
     205        return nodeID; 
     206    } 
     207 
     208    protected int getNextFreeID() 
     209    { 
     210        int nextIDHyp = nextID; 
     211        while (parents.get(nextIDHyp) != null) 
     212        { 
     213            nextIDHyp++; 
     214        } 
     215        nextID = nextIDHyp + 1; 
     216        return nextIDHyp; 
     217    } 
     218     
     219    @Override 
     220        public void clear() 
     221    { 
     222        super.clear(); 
    45223         
    46224        parents = new HashMap<Integer, Integer>(); 
    …… 
    51229        collapsed = new HashSet<Integer>(); 
    52230         
    53         terminals = new HashSet<Integer>(); 
    54     } 
    55      
    56     @Override 
    57     public int getRootID() 
    58     { 
    59         return rootID; 
    60     } 
    61      
    62     @Override 
    63         public int getRootID(int layerID) 
    64     { 
    65         return getRootID(); 
    66     } 
    67      
    68     @Override 
    69         public void setRootID(int rootID) 
    70     { 
    71         this.rootID = rootID; 
    72     } 
    73      
    74     @Override 
    75         public void addChild(int parent, int child) 
    76     { 
    77         if (parent != -1) 
    78         { 
    79             List<Integer> childIDs = children.get(parent); 
    80             if (childIDs == null) 
    81             { 
    82                 childIDs = new ArrayList<Integer>(); 
    83                 children.put(parent, childIDs); 
    84             } 
    85             childIDs.add(child); 
    86         } 
    87         parents.put(child, parent); 
    88     } 
    89      
    90     @Override 
    91         public int getParent(int nodeID, int layerID) 
    92     { 
    93         Integer parent = parents.get(nodeID); 
    94         if (parent == null) return -1; 
    95         return parent; 
    96     } 
    97      
    98     @Override 
    99         public String getNodeCaption(int nodeID) 
    100     { 
    101         String caption = nodeCaptions.get(nodeID); 
    102         if (caption == null) 
    103         { 
    104             return null; 
    105         } 
    106         else 
    107         { 
    108                 System.err.println("Caption: " + caption); // TODO 
    109             return caption; 
    110         } 
    111     } 
    112      
    113     @Override 
    114         public String getEdgeLabel(int nodeID) 
    115     { 
    116         String label = edgeLabels.get(nodeID); 
    117         if (label == null) 
    118         { 
    119             return ""; 
    120         } 
    121         else 
    122         { 
    123             return label; 
    124         } 
    125     } 
    126      
    127     @Override 
    128         public int getNodeStatus(int nodeID) 
    129     { 
    130         Integer st = status.get(nodeID); 
    131         if (st == null) 
    132         { 
    133             return 0; 
    134         } 
    135         else 
    136         { 
    137             return st; 
    138         } 
    139     } 
    140      
    141     @Override 
    142         public List<Integer> getChildren(int nodeID, int layerID) 
    143     { 
    144         //System.err.print("KahinaTree.getChildren(" + nodeID + "," + layerID + ") = "); 
    145         List<Integer> ids = children.get(nodeID); 
    146         if (ids == null) 
    147         { 
    148             //System.err.println("[]"); 
    149             return new ArrayList<Integer>(); 
    150         } 
    151         else 
    152         { 
    153             //System.err.println(ids); 
    154             return ids; 
    155         } 
    156     } 
    157      
    158     @Override 
    159         public List<Integer> getLeaves() 
    160     { 
    161         List<Integer> leaves = new LinkedList<Integer>(); 
    162         collectLeaves(rootID, leaves); 
    163         return leaves; 
    164     } 
    165      
    166     private void collectLeaves(int nodeID, List<Integer> leaves) 
    167     { 
    168         if (nodeID != -1) 
    169         { 
    170             List<Integer> nodeChildren = children.get(nodeID); 
    171             if (nodeChildren == null) 
    172             { 
    173                 leaves.add(nodeID); 
    174             } 
    175             else 
    176             { 
    177                 for (int child : nodeChildren) 
    178                 { 
    179                     collectLeaves(child, leaves); 
    180                 } 
    181             } 
    182         } 
    183     } 
    184      
    185     @Override 
    186         public boolean isCollapsed(int nodeID) 
    187     { 
    188         return collapsed.contains(nodeID); 
    189     } 
    190      
    191     @Override 
    192         public void collapse(int nodeID) 
    193     { 
    194         if (nodeID != -1) 
    195         { 
    196             collapsed.add(nodeID); 
    197         } 
    198     } 
    199      
    200     @Override 
    201         public void decollapse(int nodeID) 
    202     { 
    203         collapsed.remove(nodeID); 
    204     } 
    205      
    206     @Override 
    207         public void decollapseAll() 
    208     { 
    209         collapsed = new HashSet<Integer>(); 
    210     } 
    211      
    212     @Override 
    213         public void toggleCollapse(int nodeID) 
    214     { 
    215         if (!isCollapsed(nodeID)) 
    216         { 
    217             collapse(nodeID); 
    218         } 
    219         else 
    220         { 
    221             decollapse(nodeID); 
    222         } 
    223     } 
    224      
    225     @Override 
    226         public boolean hasCollapsedAncestor(int nodeID) 
    227     { 
    228         Integer parent = parents.get(nodeID); 
    229         while (parent != null) 
    230         { 
    231             if (isCollapsed(parent)) 
    232             { 
    233                 return true; 
    234             } 
    235             parent = parents.get(parent); 
    236         } 
    237         return false; 
    238     } 
    239      
    240     @Override 
    241         public int addNode(String caption, String label, int nodeStatus) 
    242     { 
    243         int nodeID = getNextFreeID(); 
    244         nodeCaptions.put(nodeID, caption); 
    245         edgeLabels.put(nodeID, label); 
    246         status.put(nodeID,nodeStatus); 
    247         return nodeID; 
    248     } 
    249  
    250     protected int getNextFreeID() 
    251     { 
    252         int nextIDHyp = nextID; 
    253         while (parents.get(nextIDHyp) != null) 
    254         { 
    255             nextIDHyp++; 
    256         } 
    257         nextID = nextIDHyp + 1; 
    258         return nextIDHyp; 
    259     } 
    260      
    261     @Override 
    262         public void clear() 
    263     { 
    264         super.clear(); 
    265         rootID = -1; 
    266          
    267         parents = new HashMap<Integer, Integer>(); 
    268         children = new HashMap<Integer, List<Integer>>(); 
    269         nodeCaptions = new HashMap<Integer, String>(); 
    270         edgeLabels = new HashMap<Integer, String>(); 
    271         status = new HashMap<Integer, Integer>(); 
    272         collapsed = new HashSet<Integer>(); 
    273          
    274         terminals = new HashSet<Integer>(); 
    275          
    276231        nextID = 0; 
    277232    } 
    …… 
    282237                return nodeCaptions.size(); 
    283238        } 
    284      
    285     // TODO find a good way to make this implementation-independent 
     239 
     240       // TODO find a good way to make this implementation-independent 
    286241    public static KahinaTree importXML(Document dom) 
    287242    { 
    …… 
    296251                importXMLNode(m, (Element) n, -1); 
    297252                //TODO: a little risky, root node could be assigned another ID 
    298                 m.rootID = 0; 
     253                m.setRootID(0); 
    299254                break; 
    300255            } 

  • kahina/trunk/src/org/kahina/gui/breakpoint/BreakpointTestWindow.java

    r48 r50  
    1919import org.kahina.data.KahinaTypeException; 
    2020import org.kahina.data.tree.KahinaMemTree; 
     21import org.kahina.data.tree.KahinaTree; 
    2122import org.kahina.visual.tree.KahinaTreeView; 
    2223import org.kahina.visual.tree.KahinaTreeViewMarker; 
    …… 
    2526public class BreakpointTestWindow extends JFrame implements ActionListener, KahinaListener 
    2627{ 
    27     KahinaMemTree model;    
     28    KahinaTree model;    
    2829    List<TreeAutomaton> breakpoints; 
    2930     

  • kahina/trunk/src/org/kahina/io/database/DatabaseHandler.java

    r46 r50  
    5959                } 
    6060        } 
    61  
    62         public int queryInteger(PreparedStatement statement) 
     61         
     62        public Integer queryInteger(PreparedStatement statement) 
     63        { 
     64                return queryInteger(statement, null); 
     65        } 
     66 
     67        public Integer queryInteger(PreparedStatement statement, Integer defaultValue) 
    6368        { 
    6469                try 
    …… 
    6772                        if (!resultSet.next()) 
    6873                        { 
    69                                 throw new KahinaException("No results."); 
     74                                return defaultValue; 
    7075                        } 
    7176                        return resultSet.getInt(1); 
    …… 
    109114                } 
    110115        } 
    111  
     116         
    112117        public String queryString(PreparedStatement statement) 
    113118        { 
     119                return queryString(statement, null); 
     120        } 
     121 
     122        public String queryString(PreparedStatement statement, String defaultValue) 
     123        { 
    114124                try 
    115125                { 
    …… 
    117127                        if (!resultSet.next()) 
    118128                        { 
    119                                 throw new KahinaException("No results."); 
     129                                return defaultValue; 
    120130                        } 
    121131                        return resultSet.getString(1); 
    …… 
    196206                directory.delete(); 
    197207        } 
     208 
     209        public void execute(PreparedStatement statement) 
     210        { 
     211                try 
     212                { 
     213                        statement.execute(); 
     214                } catch (SQLException e) 
     215                { 
     216                        throw new KahinaException("Failed to execute statement.", e); 
     217                } 
     218        } 
    198219} 

  • kahina/trunk/src/org/kahina/test/TestLayeredTree.java

    r46 r50  
    2626                importXMLNode(m, (Element) n, -1); 
    2727                //TODO: a little risky, root node could be assigned another ID 
    28                 m.rootID = 0; 
     28                m.setRootID(0); 
    2929                break; 
    3030            } 

  • kahina/trunk/src/org/kahina/visual/tree/KahinaTreeView.java

    r48 r50  
    602602            throw new KahinaTypeException("",""); 
    603603        } 
    604         this.secondaryTreeModel = (KahinaMemTree) treeModel; 
    605         ((KahinaMemTree) this.secondaryTreeModel).setReferenceNode(((KahinaMemTree) this.treeModel).getReferenceNode()); 
     604        this.secondaryTreeModel = (KahinaTree) treeModel; 
     605        ((KahinaTree) this.secondaryTreeModel).setReferenceNode(((KahinaTree) this.treeModel).getReferenceNode()); 
    606606        this.secondaryTreeModel.setPrimaryModel(this.treeModel); 
    607607        nodeBorderColor = new HashMap<Integer, Color>(); 
    …… 
    610610    } 
    611611     
    612     public void display(KahinaMemTree layerModel, int layerID, int referenceNode) throws KahinaTypeException 
     612    public void display(KahinaTree layerModel, int layerID, int referenceNode) throws KahinaTypeException 
    613613    { 
    614614        treeLayer = layerID; 

  • kahina/trunk/src/org/kahina/visual/tree/KahinaTreeViewListener.java

    r48 r50  
    1414import javax.swing.JOptionPane; 
    1515 
    16 import org.kahina.data.tree.KahinaMemTree; 
     16import org.kahina.data.tree.KahinaTree; 
    1717import org.kahina.visual.chart.KahinaChartView; 
    1818import org.kahina.visual.chart.KahinaChartViewContextMenu; 
    …… 
    2929    { 
    3030        this.view = view; 
    31         this.marker = new KahinaTreeViewMarker((KahinaMemTree) view.v.getTreeModel()); 
     31        this.marker = new KahinaTreeViewMarker((KahinaTree) view.v.getTreeModel()); 
    3232        this.lastMouseEvent = null; 
    3333    } 

  • kahina/trunk/src/org/kahina/visual/tree/KahinaTreeViewMarker.java

    r46 r50  
    44import java.util.Set; 
    55 
    6 import org.kahina.data.tree.KahinaMemTree; 
     6import org.kahina.data.tree.KahinaTree; 
    77 
    88public class KahinaTreeViewMarker 
    99{ 
    1010    int markedNode = -1; 
    11     KahinaMemTree model; 
    12     KahinaMemTree secondaryModel; 
     11    KahinaTree model; 
     12    KahinaTree secondaryModel; 
    1313    Set<KahinaTreeViewPanel> views; 
    1414     
    15     public KahinaTreeViewMarker(KahinaMemTree m) 
     15    public KahinaTreeViewMarker(KahinaTree m) 
    1616    { 
    1717        this.model = m; 
    …… 
    1919    } 
    2020     
    21     public KahinaTreeViewMarker(KahinaMemTree m, KahinaMemTree m2) 
     21    public KahinaTreeViewMarker(KahinaTree m, KahinaTree m2) 
    2222    { 
    2323        this.model = m; 

  • kahina/trunk/src/org/tralesld/behavior/TraleSLDTreeBehavior.java

    r46 r50  
    44 
    55import org.kahina.behavior.KahinaTreeBehavior; 
    6 import org.kahina.data.tree.KahinaMemTree; 
    76import org.kahina.data.tree.KahinaTree; 
    87import org.kahina.util.PrologUtilities; 
    …… 
    2120    int lastActiveID; 
    2221     
    23     public TraleSLDTreeBehavior(KahinaMemTree tree, KahinaTree secondaryTree) 
     22    public TraleSLDTreeBehavior(KahinaTree tree, KahinaTree secondaryTree) 
    2423    { 
    2524        super(tree);