Changeset 16b01d3


Ignore:
Timestamp:
Jun 9, 2010, 8:04:57 PM (10 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
e58398c
Parents:
89e7936
Message:

Improved memory consumption (Manual garbage collector calls and removal of unused information);

Added storage backend that caches replays;

Improved basics for enum localization;

Location:
src/main/java/de/erichseifert/warp
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • src/main/java/de/erichseifert/warp/WARP.java

    r89e7936 r16b01d3  
    2323
    2424import java.io.File;
    25 import java.util.ArrayList;
    2625import java.util.Collection;
    2726import java.util.Collections;
    2827import java.util.HashSet;
    29 import java.util.List;
     28import java.util.Set;
    3029
    3130import javax.swing.UIManager;
     
    3332
    3433import de.erichseifert.warp.gui.ReplayParserGUI;
     34import de.erichseifert.warp.io.ReplayStorage;
    3535import de.erichseifert.warp.io.SerializingStorage;
    3636import de.erichseifert.warp.io.Settings;
     
    4343        private static final int walkDepth = 3;
    4444
    45         private final List<ReplayDataChangeListener> listeners;
    46         private final SerializingStorage storage;
     45        private final Set<ReplayDataChangeListener> listeners;
     46        private final ReplayStorage storage;
    4747        private final ReplayParserGUI gui;
    4848
     
    5151         */
    5252        public WARP() {
    53                 listeners = new ArrayList<ReplayDataChangeListener>();
     53                listeners = new HashSet<ReplayDataChangeListener>();
    5454
    5555                storage = new SerializingStorage();
     
    8888
    8989                // FIXME: Do not delete all files. Check them for being up-to-date
    90                 storage.deleteAll();
     90                ((SerializingStorage) storage).deleteAll();
    9191
    9292                // Store selected directory for the next startup
  • src/main/java/de/erichseifert/warp/gui/ReplayParserGUI.java

    r89e7936 r16b01d3  
    227227                                                File replayFile = (File) replayTable.getValueAt(selectedIndex, 0);
    228228                                                Replay replay = ReplayParserGUI.this.warp.getReplay(replayFile.getAbsolutePath());
    229                                                 splitPane.add(replayRenderer.getRendererComponent((SC2Replay) replay), JSplitPane.LEFT);
     229                                                splitPane.setLeftComponent(replayRenderer.getRendererComponent((SC2Replay) replay));
     230                                                // FIXME: Find better solution
     231                                                System.gc();
    230232                                        }
    231233                                }
     
    238240        @Override
    239241        public void replaysAvailable(Collection<ReplayDescriptor> replayDescriptors) {
     242                replayTableModel.setRowCount(0);
    240243                for (ReplayDescriptor replayDescriptor : replayDescriptors) {
    241244                        replayTableModel.addRow(descriptorToRow(replayDescriptor));
  • src/main/java/de/erichseifert/warp/gui/ReplayRowFilter.java

    r89e7936 r16b01d3  
    4545                 * Filter only applies to the player names.
    4646                 */
    47                 PLAYER_NAME,
     47                PLAYER_NAME("Player name"),
    4848                /**
    4949                 * Filter only applies to the player races.
    5050                 */
    51                 PLAYER_RACE,
     51                PLAYER_RACE("Player race"),
    5252                /**
    5353                 * Filter only applies to the file names.
    5454                 */
    55                 FILE_NAME,
     55                FILE_NAME("File name"),
    5656                /**
    5757                 * Filter only applies to the player names and file names.
    5858                 */
    59                 FILE_AND_PLAYER_NAME;
     59                FILE_AND_PLAYER_NAME("File and player name");
     60
     61                private final String label;
     62
     63                private FilterMode(String label) {
     64                        this.label = label;
     65                }
    6066
    6167                @Override
    6268                public String toString() {
    63                         if (this.equals(PLAYER_NAME)) {
    64                                 return "Player name";
    65                         }
    66                         else if (this.equals(PLAYER_RACE)) {
    67                                 return "Player race";
    68                         }
    69                         else if (this.equals(FILE_NAME)) {
    70                                 return "File name";
    71                         }
    72                         else if (this.equals(FILE_AND_PLAYER_NAME)) {
    73                                 return "File and player name";
    74                         }
    75 
    76                         return null;
     69                        return label;
    7770                }
    7871        }
  • src/main/java/de/erichseifert/warp/io/ReplayStorage.java

    r89e7936 r16b01d3  
    11package de.erichseifert.warp.io;
    22
     3import java.util.Collection;
    34import java.util.List;
    45
    56import de.erichseifert.warp.Replay;
     7import de.erichseifert.warp.ReplayDescriptor;
    68
    79public interface ReplayStorage {
     
    911        List<? extends Replay> load(String... paths);
    1012        void save(Replay... replays);
     13
     14        Collection<ReplayDescriptor> getDescriptors();
    1115}
  • src/main/java/de/erichseifert/warp/io/SerializingStorage.java

    r89e7936 r16b01d3  
    3333                        File replayFile = new File(path);
    3434                        String replayFilePath = STORAGE_PATH+File.separator+fileHash(replayFile);
    35                         Replay replay = unserialize(replayFilePath);
     35                        Replay replay = deserialize(replayFilePath);
    3636                        replays.add(replay);
    3737                }
     
    3939        }
    4040
    41         private static Replay unserialize(String pathSer) {
     41        private static Replay deserialize(String pathSer) {
    4242                Replay replay = null;
     43                FileInputStream fis = null;
     44                ObjectInputStream in = null;
    4345                try {
    44                         FileInputStream fis = new FileInputStream(pathSer);
    45                         ObjectInputStream in = new ObjectInputStream(fis);
     46                        fis = new FileInputStream(pathSer);
     47                        in = new ObjectInputStream(fis);
    4648                        replay = (Replay) in.readObject();
    47                         in.close();
    4849                } catch (FileNotFoundException e) {
    4950                        // TODO Auto-generated catch block
     
    5556                        // TODO Auto-generated catch block
    5657                        e.printStackTrace();
     58                } finally {
     59                        try {
     60                                if (in != null) {
     61                                        in.close();
     62                                }
     63                                if (fis != null) {
     64                                        fis.close();
     65                                }
     66                        } catch (IOException e) {
     67                                // TODO Auto-generated catch block
     68                                e.printStackTrace();
     69                        }
    5770                }
    5871                return replay;
    5972        }
    6073
     74        // FIXME: Throw exception
    6175        @Override
    6276        public void save(Replay... replays) {
     
    6781                for (Replay replay : replays) {
    6882                        String replayFilePath = STORAGE_PATH+File.separator+fileHash(replay.getFile());
     83                        FileOutputStream fos = null;
     84                        ObjectOutputStream out = null;
    6985                        try {
    70                                 FileOutputStream fos = new FileOutputStream(replayFilePath);
    71                                 ObjectOutputStream out = new ObjectOutputStream(fos);
     86                                fos = new FileOutputStream(replayFilePath);
     87                                out = new ObjectOutputStream(fos);
    7288
    7389                                out.writeObject(replay);
    74                                 out.close();
    7590                        } catch (FileNotFoundException e) {
    7691                                // TODO Auto-generated catch block
     
    7994                                // TODO Auto-generated catch block
    8095                                e.printStackTrace();
     96                        } finally {
     97                                try {
     98                                        if (out != null) {
     99                                                out.close();
     100                                        }
     101                                        if (out != null) {
     102                                                fos.close();
     103                                        }
     104                                } catch (IOException e) {
     105                                        // TODO Auto-generated catch block
     106                                        e.printStackTrace();
     107                                }
    81108                        }
    82109                }
     
    86113                Collection<ReplayDescriptor> descriptors = new LinkedList<ReplayDescriptor>();
    87114                for (String replayPathSer : storageDir.list()) {
    88                         Replay replay = (Replay) unserialize(STORAGE_PATH+File.separator+replayPathSer);
     115                        Replay replay = (Replay) deserialize(STORAGE_PATH+File.separator+replayPathSer);
    89116                        ReplayDescriptor descriptor = replay.getDescriptor();
    90117                        descriptors.add(descriptor);
  • src/main/java/de/erichseifert/warp/replays/ReplayParserFactory.java

    r89e7936 r16b01d3  
    9595                                parser = constructor.newInstance(file);
    9696                                break;
    97                         } catch (SecurityException e) {
    98                                 // TODO Auto-generated catch block
    99                                 e.printStackTrace();
    10097                        } catch (NoSuchMethodException e) {
    10198                                // TODO Auto-generated catch block
  • src/main/java/de/erichseifert/warp/replays/sc2replay/actions/MoveScreen.java

    r89e7936 r16b01d3  
    3030         * likely to have a function like described.
    3131         */
    32         private final int srcX;
     32        /*private final int srcX;
    3333        private final int srcY;
    3434        private final int dstX;
    3535        private final int dstY;
    36         private final int flags;
     36        private final int flags;*/
    3737
    3838        public MoveScreen(int timeStamp, int eventTypeCode, boolean globalEvent, int playerIndex, ByteBuffer src) {
    3939                super(timeStamp, eventTypeCode, globalEvent, playerIndex);
    40                 srcX = src.getInt();
     40                /*srcX = src.getInt();
    4141                srcY = src.getInt();
    4242                dstX = src.getInt();
    4343                dstY = src.getInt();
    44                 flags = src.getInt();
     44                flags = src.getInt();*/
     45                src.position(src.position()+20);
    4546        }
    4647}
Note: See TracChangeset for help on using the changeset viewer.