Changeset 383

Show
Ignore:
Timestamp:
07/26/10 18:30:19 (2 years ago)
Author:
ke
Message:

Removed data managers and stores. Object storage/retrieval idioms still betray the old complicated system. Should move step magazine from Runner (static) to Instance (non-static) and make the whole architecture type-safe, especially with respect to step types. Came one step closer to successfully loading saved sessions; now failing due to some interaction between serialization and reflection?

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r382 r383  
    1515import org.kahina.core.bridge.KahinaBridge; 
    1616import org.kahina.core.control.KahinaListener; 
    17 import org.kahina.core.data.DataManager; 
    1817import org.kahina.core.data.KahinaObject; 
    1918import org.kahina.core.data.source.KahinaSourceCodeLocation; 
    …… 
    2928import org.kahina.core.gui.event.KahinaSelectionEvent; 
    3029import org.kahina.core.gui.event.KahinaUpdateEvent; 
     30import org.kahina.core.io.magazine.ObjectMagazine; 
    3131import org.kahina.core.util.FileUtilities; 
    3232import org.kahina.core.util.ProgressMonitorWrapper; 
    …… 
    153153                        monitor = gui.createProgressMonitorWrapper("Loading session", null, 0, zipFile.size()); 
    154154                        FileUtilities.unzipToDirectory(zipFile, directory, "steps/", monitor); 
    155                         KahinaRunner.getDataManager().load(directory); 
     155                        KahinaRunner.loadSteps(directory); 
    156156                        KahinaRunner.processEvent(new KahinaSelectionEvent(state.getSelectedStepID())); 
    157157                } catch (Exception e) 
    …… 
    206206                        return; 
    207207                } 
    208                 DataManager dm = KahinaRunner.getDataManager(); 
    209                 ProgressMonitorWrapper monitor = gui.createProgressMonitorWrapper("Saving session", null, 0, dm.persistSteps() * 2 + 2); 
     208                ObjectMagazine<KahinaStep> steps = KahinaRunner.getSteps(); 
     209                ProgressMonitorWrapper monitor = gui.createProgressMonitorWrapper("Saving session", null, 0, steps.persistSteps() * 2 + 2); 
    210210                ObjectOutputStream out = null; 
    211211                try 
    212212                { 
    213                         synchronized (dm) 
    214                         { 
    215                                 dm.persist(stepFolder, monitor); 
     213                        synchronized (steps) 
     214                        { 
     215                                steps.persist(stepFolder, monitor); 
    216216                        } 
    217217                        synchronized (state) 

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

    r379 r383  
    11package org.kahina.core; 
    22 
     3import java.io.File; 
     4 
    35import org.kahina.core.control.KahinaController; 
    4 import org.kahina.core.data.DataManager; 
    5 import org.kahina.core.data.KahinaDataHandlingMethod; 
    6 import org.kahina.core.data.MagazineDataManager; 
    7 import org.kahina.core.data.MemDataManager; 
     6import org.kahina.core.data.KahinaObject; 
    87import org.kahina.core.event.KahinaEvent; 
     8import org.kahina.core.io.magazine.ObjectMagazine; 
     9import org.kahina.lp.LogicProgrammingStep; 
    910 
    1011public class KahinaRunner 
    …… 
    1213        private static final boolean VERBOSE = false; 
    1314         
    14     private static DataManager dm; 
     15    private static ObjectMagazine<KahinaStep> steps; 
    1516    private static KahinaController control; 
    16     private static KahinaDataHandlingMethod dataHandlingMethod; 
    1717     
    18     public static void initialize(KahinaDataHandlingMethod dataHandlingType) 
     18    public static void initialize() 
    1919    { 
    20         dataHandlingMethod = dataHandlingType; 
    2120        control = new KahinaController(); 
    22         if (dataHandlingType == KahinaDataHandlingMethod.MEMORY) 
    23         { 
    24             setDataManager(new MemDataManager()); 
    25         } else 
    26         { 
    27                 setDataManager(new MagazineDataManager()); 
    28         } 
     21        steps = ObjectMagazine.create(); 
    2922    } 
    3023 
    …… 
    3528                        System.err.println("KahinaRunner ist deinitializing."); 
    3629                } 
    37                 dm.close(); 
    38                 dm = null; 
     30                steps.close(); 
     31                steps = null; 
    3932                control = null; 
    40                 dataHandlingMethod = null; 
    4133        } 
    42      
    43     public static DataManager getDataManager() 
    44     { 
    45         return dm; 
    46     } 
    47      
    48     private static void setDataManager(DataManager dm) 
    49     { 
    50         dm.initialize(); 
    51         KahinaRunner.dm = dm; 
    52     } 
    5334     
    5435    public static void processEvent(KahinaEvent e) 
    …… 
    6243    } 
    6344 
    64         public static KahinaDataHandlingMethod getDataHandlingMethod() 
     45        public static void store(KahinaObject object) 
    6546        { 
    66                 return dataHandlingMethod; 
     47                // TODO we want to do this differently 
     48                steps.store(object.getID(), (KahinaStep) object); 
     49        } 
     50 
     51        @SuppressWarnings("unchecked") 
     52        public static <T extends KahinaObject> T retrieve(Class<T> type, int stepID) 
     53        { 
     54                // TODO we want to do this differently 
     55                return (T) steps.retrieve(stepID); 
     56        } 
     57 
     58        public static ObjectMagazine<KahinaStep> getSteps() 
     59        { 
     60                return steps; 
     61        } 
     62 
     63        public static void loadSteps(File directory) 
     64        { 
     65                steps = ObjectMagazine.load(directory, KahinaStep.class); 
    6766        } 
    6867} 

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

    r369 r383  
    6565    } 
    6666     
     67    @Deprecated 
    6768    public void store() 
    6869    { 
    69         KahinaRunner.getDataManager().store(this); 
     70        KahinaRunner.store(this); 
    7071    } 
    7172     
     73    @Deprecated 
    7274    public void storeCaching() 
    7375    { 
    74         KahinaRunner.getDataManager().storeCaching(this); 
     76        store(); 
    7577    } 
    7678} 

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

    r379 r383  
    33import java.util.Set; 
    44 
    5 import org.kahina.core.data.KahinaDataHandlingMethod; 
    65import org.kahina.core.data.KahinaObject; 
    76import org.w3c.dom.Document; 
    …… 
    129128        } 
    130129 
    131         public static KahinaChart importXML(Document dom, KahinaDataHandlingMethod dataHandlingMethod) 
     130        public static KahinaChart importXML(Document dom) 
    132131        { 
    133132                KahinaChart m = new KahinaMemChart(); 

  • kahina/trunk/src/org/kahina/core/gui/KahinaGUI.java

    r371 r383  
    191191        public void displayStepContent(int stepID) 
    192192        { 
    193                 KahinaStep step = KahinaRunner.getDataManager().retrieve(stepType, stepID); 
     193                KahinaStep step = KahinaRunner.retrieve(KahinaStep.class, stepID); 
    194194                for (Field field : fieldToView.keySet()) 
    195195                { 

  • kahina/trunk/src/org/kahina/core/io/magazine/ObjectMagazine.java

    r382 r383  
    2323import org.kahina.core.util.ProgressMonitorWrapper; 
    2424 
    25 // TODO clean interface for saving, restoring, closing 
    2625public class ObjectMagazine<S> 
    2726{ 
    …… 
    177176        } 
    178177 
    179         public static <S> ObjectMagazine<S> create(File folder) 
    180         { 
    181                 return create(folder, 1000, 0.2F, 0.6F); 
    182         } 
    183  
    184         public static <S> ObjectMagazine<S> create(File folder, int blockSize, float lowerBound, float upperBound) 
    185         { 
    186                 if (folder.exists()) 
    187                 { 
    188                        throw new KahinaException("Cannot create magazine, file " + folder + " already exists."); 
    189                 } 
    190                 if (!folder.mkdir()) 
    191                 { 
    192                         throw new KahinaException("Could not create folder " + folder + " for magazine."); 
    193                 } 
    194                 writePropertiesFile(folder, blockSize, lowerBound, upperBound); 
    195                 return new ObjectMagazine<S>(folder, blockSize, lowerBound, upperBound, 1); 
     178        public static <S> ObjectMagazine<S> create() 
     179        { 
     180                return create(1000, 0.2F, 0.6F); 
     181        } 
     182 
     183        private static <S> ObjectMagazine<S> create(int blockSize, float lowerBound, float upperBound) 
     184        { 
     185                File directory; 
     186                try 
     187                { 
     188                       directory = FileUtilities.createTemporaryDirectory(); 
     189                } catch (IOException e) 
     190                { 
     191                        throw new KahinaException("Failed to create magazine.", e); 
     192                } 
     193                writePropertiesFile(directory, blockSize, lowerBound, upperBound); 
     194                return new ObjectMagazine<S>(directory, blockSize, lowerBound, upperBound, 1); 
    196195        } 
    197196 

  • kahina/trunk/src/org/kahina/core/test/KahinaChartTest.java

    r379 r383  
    1212import javax.xml.parsers.ParserConfigurationException; 
    1313 
    14 import org.kahina.core.data.KahinaDataHandlingMethod; 
    1514import org.kahina.core.data.chart.KahinaChart; 
    1615import org.kahina.core.visual.chart.KahinaChartView; 
    …… 
    3130            //DatabaseHandler data = new DatabaseHandler(new File("otoka.dat")); 
    3231            //KahinaChart m = KahinaChart.importXML(dom, KahinaDataHandlingMethod.DATABASE, data); 
    33             KahinaChart m = KahinaChart.importXML(dom, KahinaDataHandlingMethod.MEMORY); 
     32            KahinaChart m = KahinaChart.importXML(dom); 
    3433            KahinaChartView v = new KahinaChartView(); 
    3534            v.display(m);        

  • kahina/trunk/src/org/kahina/core/test/KahinaDAGTest.java

    r357 r383  
    1111 
    1212import org.kahina.core.KahinaRunner; 
    13 import org.kahina.core.data.KahinaDataHandlingMethod; 
    1413import org.kahina.core.data.dag.KahinaDAG; 
    1514import org.kahina.core.data.dag.KahinaMemDAG; 
    …… 
    2524        try 
    2625        {       
    27                 KahinaRunner.initialize(KahinaDataHandlingMethod.MEMORY); 
     26                KahinaRunner.initialize(); 
    2827                 
    2928            File file = new File("src/org/kahina/core/test/test-dag.xml"); 

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

    r379 r383  
    1313 
    1414import org.kahina.core.KahinaRunner; 
    15 import org.kahina.core.data.KahinaDataHandlingMethod; 
    1615import org.kahina.core.data.tree.KahinaMemTree; 
    1716import org.kahina.core.data.tree.KahinaTree; 
    …… 
    6059            v0.setStatusColorEncoding(3,new Color(255,255,255));  
    6160             
    62             KahinaRunner.initialize(KahinaDataHandlingMethod.MEMORY); 
     61            KahinaRunner.initialize(); 
    6362            KahinaRunner.getControl().registerListener("select", v0); 
    6463            KahinaRunner.getControl().registerListener("update", v0); 

  • kahina/trunk/src/org/kahina/lp/LogicProgrammingStep.java

    r379 r383  
    5959    public static LogicProgrammingStep get(int id) 
    6060    { 
    61         return KahinaRunner.getDataManager().retrieve(LogicProgrammingStep.class, id); 
     61        return KahinaRunner.retrieve(LogicProgrammingStep.class, id); 
    6262    } 
    6363} 

  • kahina/trunk/src/org/kahina/tralesld/TraleSLDRunner.java

    r379 r383  
    22 
    33import org.kahina.core.KahinaRunner; 
    4 import org.kahina.core.KahinaStep; 
    5 import org.kahina.core.data.DataManager; 
    6 import org.kahina.core.data.KahinaDataHandlingMethod; 
    7 import org.kahina.core.data.source.KahinaSourceCodeLocation; 
    8 import org.kahina.core.data.source.KahinaSourceFileModel; 
    9 import org.kahina.core.data.text.KahinaText; 
    10 import org.kahina.core.data.text.KahinaTextModel; 
    11 import org.kahina.lp.LogicProgrammingStep; 
    124import org.kahina.tralesld.bridge.TraleSLDBridge; 
    13 import org.kahina.tralesld.data.fs.TraleSLDPackedFSNonTerminal; 
    14 import org.kahina.tralesld.data.fs.TraleSLDPackedFSTerminal; 
    15 import org.kahina.tralesld.data.fs.TraleSLDVariableBinding; 
    16 import org.kahina.tralesld.data.fs.TraleSLDVariableBindingSet; 
    175 
    186public class TraleSLDRunner extends KahinaRunner 
    …… 
    5947        } 
    6048 
    61         public static void initialize(KahinaDataHandlingMethod dataHandlingType) 
     49        public static void initialize() 
    6250        { 
    63                 KahinaRunner.initialize(dataHandlingType); 
    64                 DataManager dm = KahinaRunner.getDataManager(); 
    65                 dm.registerDataType(KahinaStep.class); 
    66                 dm.registerDataType(LogicProgrammingStep.class); 
    67                 dm.registerDataType(TraleSLDStep.class); 
    68                 dm.registerDataType(TraleSLDPackedFSNonTerminal.class); 
    69                 dm.registerDataType(TraleSLDPackedFSTerminal.class); 
    70                 dm.registerDataType(KahinaSourceCodeLocation.class); 
    71                 dm.registerDataType(KahinaSourceFileModel.class); 
    72                 dm.registerDataType(TraleSLDVariableBinding.class); 
    73                 dm.registerDataType(TraleSLDVariableBindingSet.class); 
    74                 dm.registerDataType(KahinaTextModel.class); 
    75                 dm.registerDataType(KahinaText.class); 
     51                KahinaRunner.initialize(); 
    7652        } 
    7753 
    …… 
    8056                try 
    8157                { 
    82                         initialize(KahinaDataHandlingMethod.MAGAZINE); 
     58                        initialize(); 
    8359                        TraleSLDInstance kahina = new TraleSLDInstance(); 
    8460                        kahina.getGUI().prepare(); 

  • kahina/trunk/src/org/kahina/tralesld/TraleSLDStep.java

    r370 r383  
    3333    public static TraleSLDStep get(int id) 
    3434    { 
    35         return KahinaRunner.getDataManager().retrieve(TraleSLDStep.class, id); 
     35        return KahinaRunner.retrieve(TraleSLDStep.class, id); 
    3636    } 
    3737} 

  • kahina/trunk/src/org/kahina/tulipa/TulipaRunner.java

    r379 r383  
    22 
    33import org.kahina.core.KahinaRunner; 
    4 import org.kahina.core.KahinaStep; 
    5 import org.kahina.core.data.DataManager; 
    6 import org.kahina.core.data.KahinaDataHandlingMethod; 
    7 import org.kahina.core.data.source.KahinaSourceCodeLocation; 
    8 import org.kahina.core.data.source.KahinaSourceFileModel; 
    9 import org.kahina.core.data.text.KahinaText; 
    10 import org.kahina.core.data.text.KahinaTextModel; 
    114import org.kahina.tulipa.bridge.TulipaBridge; 
    125 
    136public class TulipaRunner extends KahinaRunner 
    147{ 
    15     public static void initialize(KahinaDataHandlingMethod dataHandlingType) 
     8    public static void initialize() 
    169    { 
    17         KahinaRunner.initialize(dataHandlingType); 
    18         DataManager dm = KahinaRunner.getDataManager(); 
    19         dm.registerDataType(KahinaStep.class); 
    20         dm.registerDataType(KahinaSourceCodeLocation.class); 
    21         dm.registerDataType(KahinaSourceFileModel.class); 
    22         dm.registerDataType(KahinaTextModel.class); 
    23         dm.registerDataType(TulipaStep.class); 
    24         dm.registerDataType(KahinaText.class); 
    25         /*dm.registerDataType(KahinaLineReference.class); 
    26         dm.registerDataType(LogicProgrammingLineReference.class); 
    27         dm.registerDataType(KahinaText.class);*/ 
     10        KahinaRunner.initialize(); 
    2811    } 
    2912     
    …… 
    3114    { 
    3215        System.err.println("Starting Kahina.TuLiPa instance..."); 
    33         initialize(KahinaDataHandlingMethod.MEMORY); 
     16        initialize(); 
    3417        TulipaInstance kahina = new TulipaInstance(); 
    3518        kahina.getGUI().prepare(); 

  • kahina/trunk/src/org/kahina/tulipa/TulipaStep.java

    r369 r383  
    3737    public static TulipaStep get(int id) 
    3838    { 
    39         return KahinaRunner.getDataManager().retrieve(TulipaStep.class, id); 
     39        return KahinaRunner.retrieve(TulipaStep.class, id); 
    4040    } 
    4141} 

  • kahina/trunk/test/org/kahina/tralesld/data/fs/BracketPackerTest.java

    r379 r383  
    1111 
    1212import org.junit.Test; 
    13 import org.kahina.core.data.DataManager; 
    14 import org.kahina.core.data.MemDataManager; 
    1513 
    1614public class BracketPackerTest 
    …… 
    1816         
    1917        @Test 
    20         public void memTest() 
    21         { 
    22                 DataManager dm = new MemDataManager(); 
    23                 dm.registerDataType(TraleSLDPackedFSNonTerminal.class); 
    24                 dm.registerDataType(TraleSLDPackedFSTerminal.class); 
    25                 test(dm); 
    26         } 
    27          
    28         public void test(DataManager dm) 
     18        public void test1() 
    2919        { 
    3020                TraleSLDFSPacker packer = new TraleSLDFSPacker(); 
    3121                Scanner scanner = new Scanner(Main.class.getResourceAsStream("/gralej/resource/sample.GRALE")); 
    3222                List<String> lines = new ArrayList<String>(); 
    33                 List<Integer> results = new ArrayList<Integer>(); 
     23                List<TraleSLDFS> results = new ArrayList<TraleSLDFS>(); 
    3424                while (scanner.hasNextLine()) 
    3525                { 
    36                         packAndStore(scanner.nextLine(), dm, lines, results, packer); 
     26                        pack(scanner.nextLine(), lines, results, packer); 
    3727                } 
    38                 packAndStore("bla(a)))", dm, lines, results, packer); 
    39                 packAndStore("a\"aa", dm, lines, results, packer); 
    40                 packAndStore("\"\"", dm, lines, results, packer); 
    41                 packAndStore("\"aaaaaaaaa", dm, lines, results, packer); 
    42                 packAndStore("(\"))(\"", dm, lines, results, packer); 
    43                 packAndStore("(((a)alb", dm, lines, results, packer); 
    44                 Iterator<Integer> resultsIterator = results.iterator(); 
     28                pack("bla(a)))", lines, results, packer); 
     29                pack("a\"aa", lines, results, packer); 
     30                pack("\"\"", lines, results, packer); 
     31                pack("\"aaaaaaaaa", lines, results, packer); 
     32                pack("(\"))(\"", lines, results, packer); 
     33                pack("(((a)alb", lines, results, packer); 
     34                Iterator<TraleSLDFS> resultsIterator = results.iterator(); 
    4535                for (String original : lines) 
    4636                { 
    47                         String result = dm.retrieve(resultsIterator.next()).toString(); 
     37                        String result = resultsIterator.next().toString(); 
    4838                        Assert.assertEquals(original, result); 
    4939                } 
    5040        } 
    5141         
    52         private void packAndStore(String original, DataManager dm, List<String> originals, List<Integer> packedObjectIDs, TraleSLDFSPacker packer) 
     42        private void pack(String original, List<String> originals, List<TraleSLDFS> fss, TraleSLDFSPacker packer) 
    5343        { 
    5444                TraleSLDFS fs = packer.pack(original); 
    55                 dm.store(fs); 
    5645                originals.add(original); 
    57                 packedObjectIDs.add(fs.getID()); 
     46                fss.add(fs); 
    5847        } 
    5948