Changeset 46

Show
Ignore:
Timestamp:
02/20/10 13:59:04 (2 years ago)
Author:
ke
Message:

Preparatory refactoring of tree classes.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r42 r46  
    77import org.kahina.control.KahinaController; 
    88import org.kahina.control.event.KahinaTreeMatchEvent; 
    9 import org.kahina.data.tree.KahinaMemTree; 
     9import org.kahina.data.tree.KahinaUnlayeredMemTree; 
    1010import org.kahina.data.tree.KahinaTree; 
    1111 
    …… 
    5050        rules = new HashSet<TreeAutomatonRule>(); 
    5151         
    52         this.tree = new KahinaMemTree(); 
     52        this.tree = new KahinaUnlayeredMemTree(); 
    5353        this.annotations =  new HashMap<Integer,Set<Integer>>(); 
    5454        this.bp = bp;     

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

    r19 r46  
    11package org.kahina.core; 
    22 
    3 import org.kahina.data.tree.KahinaLayeredTree; 
     3import org.kahina.data.tree.KahinaMemTree; 
    44import org.kahina.data.tree.KahinaTree; 
    55 
    …… 
    1717{       
    1818    //the data structures that a kahina state always contains 
    19     KahinaLayeredTree stepTree; 
     19    KahinaMemTree stepTree; 
    2020    KahinaTree secondaryStepTree;  
    2121} 

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

    r33 r46  
    116116                        return; 
    117117                } 
    118                 try 
    119                 { 
    120                         db.execute("CREATE TABLE " + OBJECT_TABLE_NAME + " (" 
    121                                         + "class_id INT, " + "object_id INT, " + "field_id INT, " 
    122                                         + "value_class_id INT, " + "value_object_id INT, " 
    123                                         + "INDEX id (class_id, object_id, field_id)" + "); " 
    124                                         + "CREATE TABLE KahinaObjectDbDataStore_string_values " 
    125                                         + "(" + "class_id INT, " + "object_id INT, " 
    126                                         + "field_id INT, " + "value LONG VARCHAR, " 
    127                                         + "INDEX id (class_id, object_id, field_id)" + "); " 
    128                                         + "CREATE TABLE KahinaObjectDbDataStore_int_values " + "(" 
    129                                         + "class_id INT, " + "object_id INT, " + "field_id INT, " 
    130                                         + "value INT, " 
    131                                         + "INDEX id (class_id, object_id, field_id)" + "); "); 
    132                 } catch (SQLException e) 
    133                 { 
    134                         throw new KahinaException("Could not create tables. ", e); 
    135                 } 
     118                db.execute("CREATE TABLE " + OBJECT_TABLE_NAME + " (" 
     119                                + "class_id INT, " + "object_id INT, " + "field_id INT, " 
     120                                + "value_class_id INT, " + "value_object_id INT, " 
     121                                + "INDEX id (class_id, object_id, field_id)" + "); " 
     122                                + "CREATE TABLE KahinaObjectDbDataStore_string_values " + "(" 
     123                                + "class_id INT, " + "object_id INT, " + "field_id INT, " 
     124                                + "value LONG VARCHAR, " 
     125                                + "INDEX id (class_id, object_id, field_id)" + "); " 
     126                                + "CREATE TABLE KahinaObjectDbDataStore_int_values " + "(" 
     127                                + "class_id INT, " + "object_id INT, " + "field_id INT, " 
     128                                + "value INT, " + "INDEX id (class_id, object_id, field_id)" 
     129                                + "); "); 
    136130                db.register(CLIENT_ID); 
    137131        } 

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

    r33 r46  
    1414 
    1515        private static final String TABLE_NAME_PREFIX = KahinaDbChart.class 
    16                         .getSimpleName() + "_"; 
     16                        .getSimpleName() 
     17                        + "_"; 
    1718 
    1819        private static final String CHART_TABLE_NAME = TABLE_NAME_PREFIX + "charts"; 
    …… 
    8889                if (!db.isRegistered(CLIENT_ID)) 
    8990                { 
    90                         try 
    91                         { 
    92                                 // create table for KahinaCharts 
    93                                 db.execute("CREATE TABLE " + CHART_TABLE_NAME + " (" 
    94                                                 + "id INT," + "leftBound INT," + "rightBound INT," 
    95                                                 + "leftmostCovered INT," + "rightmostCovered INT," 
    96                                                 + "PRIMARY KEY (id)" + ")"); 
    97                                 // create a table for the chart segments 
    98                                 db.execute("CREATE TABLE " + SEGMENT_TABLE_NAME + " (" 
    99                                                 + "id INT," + "chart INT," + "caption LONG VARCHAR," 
    100                                                 + "PRIMARY KEY (id, chart)" + ")"); 
    101                                 // create a table for the chart edges 
    102                                 db.execute("CREATE TABLE " + EDGE_TABLE_NAME + " (" + "id INT," 
    103                                                 + "chart INT," + "leftBound INT," + "rightBound INT," 
    104                                                 + "caption LONG VARCHAR," + "status INT," 
    105                                                 + "PRIMARY KEY (id, chart)" + ")"); 
    106                         } catch (SQLException e) 
    107                         { 
    108                                 throw new KahinaException("Failed to create tables. ", e); 
    109                         } 
     91                        // create table for KahinaCharts 
     92                        db.execute("CREATE TABLE " + CHART_TABLE_NAME + " (" + "id INT," 
     93                                        + "leftBound INT," + "rightBound INT," 
     94                                        + "leftmostCovered INT," + "rightmostCovered INT," 
     95                                        + "PRIMARY KEY (id)" + ")"); 
     96                        // create a table for the chart segments 
     97                        db.execute("CREATE TABLE " + SEGMENT_TABLE_NAME + " (" + "id INT," 
     98                                        + "chart INT," + "caption LONG VARCHAR," 
     99                                        + "PRIMARY KEY (id, chart)" + ")"); 
     100                        // create a table for the chart edges 
     101                        db.execute("CREATE TABLE " + EDGE_TABLE_NAME + " (" + "id INT," 
     102                                        + "chart INT," + "leftBound INT," + "rightBound INT," 
     103                                        + "caption LONG VARCHAR," + "status INT," 
     104                                        + "PRIMARY KEY (id, chart)" + ")"); 
    110105                        db.register(CLIENT_ID); 
    111106                } 
    …… 
    114109        private void createChart() 
    115110        { 
    116                 try 
    117                 { 
    118                         db 
    119                                         .execute("INSERT INTO " 
    120                                                         + CHART_TABLE_NAME 
    121                                                         + " (id, leftBound, rightBound, leftmostCovered, rightmostCovered) VALUES (" 
    122                                                         + getID() + ", 0, 0, 0, 0)"); 
    123                 } catch (SQLException e) 
    124                 { 
    125                         throw new KahinaException("Failed to create chart."); 
    126                 } 
     111                db 
     112                                .execute("INSERT INTO " 
     113                                                + CHART_TABLE_NAME 
     114                                                + " (id, leftBound, rightBound, leftmostCovered, rightmostCovered) VALUES (" 
     115                                                + getID() + ", 0, 0, 0, 0)"); 
    127116        } 
    128117 

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

    r42 r46  
    99import org.w3c.dom.NodeList; 
    1010 
    11 public class KahinaLayeredTree extends KahinaMemTree 
     11public class KahinaMemTree extends KahinaUnlayeredMemTree 
    1212{    
    1313    //reference node should always be the same across views, so store it here 
    1414    int referenceNode; 
     15     
     16    public KahinaMemTree() 
     17    { 
     18        this(new DefaultLayerDecider()); 
     19    } 
    1520 
    16     public KahinaLayeredTree() 
     21    public KahinaMemTree(LayerDecider decider) 
    1722    { 
    18         super(); 
     23        super(decider); 
    1924        referenceNode = super.getRootID(0); 
    2025    }  
    …… 
    3439        if (layerID == 0) return super.getRootID(0); 
    3540        int rootID = referenceNode; 
    36         while (decideOnLevel(rootID) >= layerID) 
     41        while (decider.decideOnLayer(rootID, this) >= layerID) 
    3742        { 
    3843            rootID = super.getParent(rootID,0); 
    …… 
    4550        if (nodeID == getRootID(layerID)) return -1; 
    4651        int parent = super.getParent(nodeID,0); 
    47         while (decideOnLevel(parent) > layerID) 
     52        while (decider.decideOnLayer(parent, this) > layerID) 
    4853        { 
    4954            parent = super.getParent(parent,0); 
    …… 
    5863        List<Integer> chi = new ArrayList<Integer>(); 
    5964        List<Integer> frontLine = new ArrayList<Integer>(); 
    60         if (nodeID == getRootID(layerID) || decideOnLevel(nodeID) >= layerID) 
     65        if (nodeID == getRootID(layerID) || decider.decideOnLayer(nodeID, this) >= layerID) 
    6166        { 
    6267            frontLine.addAll(super.getChildren(nodeID, layerID)); 
    …… 
    6772            int child = frontLine.remove(0); 
    6873            //System.err.println("child: " + child + " level: " + decideOnLevel(child)); 
    69             if (decideOnLevel(child) <= layerID) 
     74            if (decider.decideOnLayer(child, this) <= layerID) 
    7075            { 
    7176                chi.add(child); 
    …… 
    8186    } 
    8287     
    83     //this method should be implemented by deriving classes! 
    84     //full access to the tree model, can thus be based on node info, tree structure, status information 
    85     //default version: all the nodes belong to level 0 
    86     public int decideOnLevel(int nodeID) 
     88    public static KahinaMemTree importXML(Document dom) 
    8789    { 
    88         return 0; 
    89     } 
    90      
    91     public static KahinaLayeredTree importXML(Document dom) 
    92     { 
    93         KahinaLayeredTree m = new KahinaLayeredTree(); 
     90        KahinaMemTree m = new KahinaMemTree(); 
    9491        Element treeElement = dom.getDocumentElement();   
    9592        NodeList childNodes = treeElement.getChildNodes(); 
    …… 
    108105    } 
    109106     
    110     private static void importXMLNode(KahinaLayeredTree m, Element node, int parentID) 
     107    private static void importXMLNode(KahinaMemTree m, Element node, int parentID) 
    111108    { 
    112109        int nodeID = 0; 

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

    r44 r46  
    99{ 
    1010        private static int nextID = 0; 
     11         
     12        protected LayerDecider decider; 
    1113 
    12         public KahinaTree() 
     14        private KahinaTree primaryModel; 
     15 
     16        public KahinaTree(LayerDecider decider) 
    1317        { 
    1418                super(nextID++); 
     19                this.decider = decider; 
     20                clear(); 
    1521        } 
    1622 
    17         public abstract void clear(); 
     23        /** 
     24         * Clears the tree model. Implementors should override this method to clear 
     25         * implementation-specific data, but make sure to call this implementation 
     26         * using <code>super.clear()</code>. 
     27         */ 
     28        public void clear() 
     29        { 
     30                setPrimaryModel(this); 
     31        } 
    1832 
    1933        public abstract int addNode(String caption, String label, int nodeStatus); 
    …… 
    6276 
    6377        public abstract int getRootID(int layerID); 
    64  
    65         public abstract void setPrimaryModel(KahinaTree primaryModel); 
    6678     
    6779    public String exportXML() 
    …… 
    97109    } 
    98110 
     111        public KahinaTree getPrimaryModel() 
     112        { 
     113                return primaryModel; 
     114        } 
     115 
     116        public void setPrimaryModel(KahinaTree primaryModel) 
     117        { 
     118            this.primaryModel = primaryModel; 
     119        } 
     120 
    99121} 

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

    r44 r46  
    1414import org.w3c.dom.NodeList; 
    1515 
    16 public class KahinaMemTree extends KahinaTree 
     16/** 
     17 * A simple Kahina tree implementation which does not support layers. 
     18 */ 
     19public class KahinaUnlayeredMemTree extends KahinaTree 
    1720{     
    1821    //empty tree has rootID = -1 
    …… 
    3134    //store the ID of the next node that is going to be added 
    3235    private int nextID = 0; 
    33     //internal link to the primary model, must sometimes be used for decisions 
    34     protected KahinaTree primaryModel; 
    35      
    36     public KahinaMemTree() 
     36    public KahinaUnlayeredMemTree() 
     37    { 
     38        this(new DefaultLayerDecider()); 
     39    } 
     40     
     41    public KahinaUnlayeredMemTree(LayerDecider decider) 
    3742    {         
     43        super(decider); 
    3844        rootID = -1; 
    3945         
    …… 
    4652         
    4753        terminals = new HashSet<Integer>(); 
    48          
    49         primaryModel = this; 
    50     } 
    51      
    52     @Override 
    53         public void setPrimaryModel(KahinaTree primaryModel) 
    54     { 
    55         this.primaryModel = primaryModel; 
    5654    } 
    5755     
    …… 
    299297        public void clear() 
    300298    { 
     299        super.clear(); 
    301300        rootID = -1; 
    302301         
    …… 
    310309        terminals = new HashSet<Integer>(); 
    311310         
    312         primaryModel = this; 
    313          
    314311        nextID = 0; 
    315312    } 
    316313     
    317314    // TODO find a good way to make this implementation-independent 
    318     public static KahinaMemTree importXML(Document dom) 
    319     { 
    320         KahinaMemTree m = new KahinaMemTree(); 
     315    public static KahinaTree importXML(Document dom) 
     316    { 
     317        KahinaUnlayeredMemTree m = new KahinaUnlayeredMemTree(); 
    321318        Element treeElement = dom.getDocumentElement();   
    322319        NodeList childNodes = treeElement.getChildNodes(); 
    …… 
    335332    } 
    336333     
    337     private static void importXMLNode(KahinaMemTree m, Element node, int parentID) 
     334    private static void importXMLNode(KahinaUnlayeredMemTree m, Element node, int parentID) 
    338335    { 
    339336        int nodeID = 0; 

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

    r34 r46  
    1919import org.kahina.control.event.KahinaTreeMatchEvent; 
    2020import org.kahina.data.KahinaTypeException; 
    21 import org.kahina.data.tree.KahinaLayeredTree; 
     21import org.kahina.data.tree.KahinaMemTree; 
    2222import org.kahina.visual.tree.KahinaTreeView; 
    2323import org.kahina.visual.tree.KahinaTreeViewMarker; 
    …… 
    2626public class BreakpointTestWindow extends JFrame implements ActionListener, KahinaListener 
    2727{ 
    28     KahinaLayeredTree model;    
     28    KahinaMemTree model;    
    2929    List<TreeAutomaton> breakpoints; 
    3030     
    …… 
    5050        mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.PAGE_AXIS)); 
    5151         
    52         model = new KahinaLayeredTree(); 
     52        model = new KahinaMemTree(); 
    5353        int rootID = model.addNode("start", "none", 0); 
    5454        model.setRootID(rootID); 

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

    r31 r46  
    4848        } 
    4949 
    50         public void execute(String sqlString) throws SQLException 
     50        public void execute(String sqlString) 
    5151        { 
    52                 Statement statement = connection.createStatement(); 
    53                 statement.execute(sqlString); 
     52                try 
     53                { 
     54                        Statement statement = connection.createStatement(); 
     55                        statement.execute(sqlString); 
     56                } catch (SQLException e) 
     57                { 
     58                        throw new KahinaException("SQL error.", e); 
     59                } 
    5460        } 
    5561 

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

    r45 r46  
    22 
    33import java.awt.Color; 
    4 import java.awt.Font; 
    54import java.io.File; 
    65import java.io.IOException; 
    …… 
    1413 
    1514import org.kahina.data.KahinaTypeException; 
    16 import org.kahina.data.tree.KahinaTree; 
    1715import org.kahina.visual.tree.KahinaTreeView; 
    1816import org.kahina.visual.tree.KahinaTreeViewMarker; 

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

    r34 r46  
    11package org.kahina.test; 
    22 
    3 import org.kahina.data.tree.KahinaLayeredTree; 
     3import org.kahina.data.tree.KahinaMemTree; 
    44import org.w3c.dom.Document; 
    55import org.w3c.dom.Element; 
    …… 
    77import org.w3c.dom.NodeList; 
    88 
    9 public class TestLayeredTree extends KahinaLayeredTree 
     9public class TestLayeredTree extends KahinaMemTree 
    1010{ 
    11     //this method should be implemented by deriving classes! 
    12     //full access to the tree model, can thus be based on node info, tree structure, status information 
    13     //TODO: in the case of the secondary tree model, use the captions from the primary model instead! 
    14     public int decideOnLevel(int nodeID) 
    15     { 
    16         if (nodeID == getRootID(0)) return 0; 
    17         if (nodeID == -1) return -1; 
    18         if (primaryModel.getNodeCaption(nodeID).indexOf("rule") != -1 || primaryModel.getNodeCaption(nodeID).indexOf("\"") != -1) return 0; 
    19         else if (primaryModel.getNodeCaption(nodeID).indexOf("goal") != -1) return 1; 
    20         return 2; 
    21     } 
     11        public TestLayeredTree() 
     12        { 
     13                super(new TestLayerDecider()); 
     14        } 
    2215     
    2316    public static TestLayeredTree importXML(Document dom) 

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

    r34 r46  
    1515import org.kahina.data.KahinaTypeException; 
    1616import org.kahina.data.tree.KahinaTree; 
    17 import org.kahina.data.tree.KahinaLayeredTree; 
     17import org.kahina.data.tree.KahinaMemTree; 
    1818import org.kahina.visual.KahinaView; 
    1919 
    …… 
    123123    public KahinaTreeView() 
    124124    { 
    125         treeModel = new KahinaLayeredTree(); 
     125        treeModel = new KahinaMemTree(); 
    126126        treeLayer = 0; 
    127127        secondaryTreeModel = null; 
    …… 
    588588        } 
    589589        treeLayer = 0; 
    590         this.treeModel = (KahinaLayeredTree) treeModel; 
     590        this.treeModel = (KahinaMemTree) treeModel; 
    591591        nodeBorderColor = new HashMap<Integer, Color>(); 
    592592        resetAllStructures(); 
    …… 
    600600            throw new KahinaTypeException("",""); 
    601601        } 
    602         this.secondaryTreeModel = (KahinaLayeredTree) treeModel; 
    603         ((KahinaLayeredTree) this.secondaryTreeModel).setReferenceNode(((KahinaLayeredTree) this.treeModel).getReferenceNode()); 
     602        this.secondaryTreeModel = (KahinaMemTree) treeModel; 
     603        ((KahinaMemTree) this.secondaryTreeModel).setReferenceNode(((KahinaMemTree) this.treeModel).getReferenceNode()); 
    604604        this.secondaryTreeModel.setPrimaryModel(this.treeModel); 
    605605        nodeBorderColor = new HashMap<Integer, Color>(); 
    …… 
    608608    } 
    609609     
    610     public void display(KahinaLayeredTree layerModel, int layerID, int referenceNode) throws KahinaTypeException 
     610    public void display(KahinaMemTree layerModel, int layerID, int referenceNode) throws KahinaTypeException 
    611611    { 
    612612        treeLayer = layerID; 

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

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

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

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

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

    r8 r46  
    44 
    55import org.kahina.behavior.KahinaTreeBehavior; 
    6 import org.kahina.data.tree.KahinaLayeredTree; 
     6import org.kahina.data.tree.KahinaMemTree; 
    77import org.kahina.data.tree.KahinaTree; 
    88import org.kahina.util.PrologUtilities; 
    …… 
    2121    int lastActiveID; 
    2222     
    23     public TraleSLDTreeBehavior(KahinaLayeredTree tree, KahinaTree secondaryTree) 
     23    public TraleSLDTreeBehavior(KahinaMemTree tree, KahinaTree secondaryTree) 
    2424    { 
    2525        super(tree);