Changeset 0438dfb


Ignore:
Timestamp:
Jun 13, 2010, 10:20:41 AM (10 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
f37caa2
Parents:
9f43973
Message:

Added a window that shows the progress when parsing replays;

Already stored replays are not save again

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

Legend:

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

    r9f43973 r0438dfb  
    5151        private class ParserThread extends Thread {
    5252                private final File dir;
     53                private final ProgressListener listener;
    5354
    54                 public ParserThread(File dir) {
     55                public ParserThread(File dir, ProgressListener listener) {
    5556                        this.dir = dir;
     57                        this.listener = listener;
    5658                }
    5759
     
    6062                        Collection<File> replayFiles = FileUtil.walk(dir, walkDepth);
    6163
     64                        int elementsProcessed = 0;
    6265                        for (File replayFile : replayFiles) {
     66                                if (storage.contains(replayFile)) {
     67                                        elementsProcessed++;
     68                                        continue;
     69                                }
    6370                                Replay replay = ReplayParserFactory.getInstance().getReplayParser(replayFile);
    6471                                storage.save(replay);
     72                                elementsProcessed++;
    6573
    6674                                fireReplayInfoChanged(null, replay.getDescriptor());
     75                                listener.progressUpdated(elementsProcessed, replayFiles.size());
    6776                        }
    6877
     
    118127         * @param dir
    119128         */
    120         public void parseDir(File dir) {
     129        public void parseDir(File dir, ProgressListener listener) {
    121130                if (dir == null) {
    122131                        return;
     
    126135                Settings.getInstance().setReplayDir(dir.getPath());
    127136
    128                 ParserThread parserThread = new ParserThread(dir);
     137                ParserThread parserThread = new ParserThread(dir, listener);
    129138                parserThread.start();
    130139        }
  • src/main/java/de/erichseifert/warp/gui/ReplayParserGUI.java

    r9f43973 r0438dfb  
    104104                                int option = fileChooser.showOpenDialog(ReplayParserGUI.this);
    105105                                if (option == JFileChooser.APPROVE_OPTION) {
    106                                         ReplayParserGUI.this.warp.parseDir(fileChooser.getSelectedFile());
     106                                        ParseReplayWindow parsingProgress = new ParseReplayWindow(ReplayParserGUI.this);
     107                                        parsingProgress.setVisible(true);
     108
     109                                        ReplayParserGUI.this.warp.parseDir(fileChooser.getSelectedFile(), parsingProgress);
    107110                                }
    108111                        }
  • src/main/java/de/erichseifert/warp/io/BufferedStorage.java

    r9f43973 r0438dfb  
    11package de.erichseifert.warp.io;
    22
     3import java.io.File;
    34import java.util.ArrayList;
    45import java.util.LinkedHashMap;
     
    104105                return storage.size();
    105106        }
     107
     108        @Override
     109        public boolean contains(File replayFile) {
     110                return storage.contains(replayFile);
     111        }
    106112}
  • src/main/java/de/erichseifert/warp/io/MemoryStorage.java

    r9f43973 r0438dfb  
    11package de.erichseifert.warp.io;
    22
     3import java.io.File;
    34import java.util.ArrayList;
    45import java.util.HashMap;
     
    6263                return cache.size();
    6364        }
     65
     66        @Override
     67        public boolean contains(File replayFile) {
     68                return cache.containsValue(replayFile);
     69        }
    6470}
  • src/main/java/de/erichseifert/warp/io/ReplayStorage.java

    r9f43973 r0438dfb  
    11package de.erichseifert.warp.io;
    22
     3import java.io.File;
    34import java.util.List;
    45import java.util.Set;
     
    4243         */
    4344        int size();
     45
     46        /**
     47         * Returns, whether the specified replay has already been stored or not.
     48         * @param replay File to the unparsed replay.
     49         * @return <code>true</code> if the replay already has been stored.
     50         */
     51        boolean contains(File replayFile);
    4452}
  • src/main/java/de/erichseifert/warp/io/SerializingStorage.java

    r9f43973 r0438dfb  
    88import java.io.ObjectInputStream;
    99import java.io.ObjectOutputStream;
    10 import java.util.Collections;
     10import java.util.HashMap;
    1111import java.util.HashSet;
    1212import java.util.LinkedList;
    1313import java.util.List;
     14import java.util.Map;
    1415import java.util.Set;
    1516
     
    2627        private static final String DESCRIPTOR_FILE_NAME = ".descriptors";
    2728
    28         private Set<ReplayDescriptor> descriptors;
     29        private Map<String, ReplayDescriptor> descriptorsByPath;
    2930        private File storageDir;
    3031        private File descriptorFile;
     
    106107         */
    107108        private void initDescriptorCache() {
    108                 if (descriptors != null) {
     109                if (descriptorsByPath != null) {
    109110                        return;
    110111                }
    111112
    112113                if (descriptorFile.exists()) {
    113                         descriptors = (Set<ReplayDescriptor>) deserialize(descriptorFile.getAbsolutePath());
     114                        descriptorsByPath = (Map<String, ReplayDescriptor>) deserialize(descriptorFile.getAbsolutePath());
    114115                }
    115116                else {
    116                         descriptors = new HashSet<ReplayDescriptor>();
     117                        descriptorsByPath = new HashMap<String, ReplayDescriptor>();
    117118                }
    118119        }
     
    130131                        String replayFilePath = getSerializationPath(storageDir, replay.getDescriptor().getFile());
    131132                        serialize(replay, replayFilePath);
    132                         descriptors.add(replay.getDescriptor());
     133                        descriptorsByPath.put(replay.getDescriptor().getFile().getAbsolutePath(), replay.getDescriptor());
    133134                }
    134135
    135136                // Serialize replay descriptors
    136                 serialize(descriptors, descriptorFile.getAbsolutePath());
     137                serialize(descriptorsByPath, descriptorFile.getAbsolutePath());
     138        }
     139
     140        @Override
     141        public boolean contains(File replayFile) {
     142                initDescriptorCache();
     143                ReplayDescriptor descriptor = descriptorsByPath.get(replayFile.getAbsolutePath());
     144                if (descriptor == null) {
     145                        return false;
     146                }
     147                return true;
    137148        }
    138149
     
    140151        public Set<ReplayDescriptor> getDescriptors() {
    141152                initDescriptorCache();
    142                 return Collections.unmodifiableSet(descriptors);
     153                return new HashSet<ReplayDescriptor>(descriptorsByPath.values());
    143154        }
    144155
     
    152163                        serializedFile.delete();
    153164
    154                         descriptors.remove(replay.getDescriptor());
     165                        descriptorsByPath.remove(replay.getDescriptor().getFile());
    155166                }
    156167
    157168                // Serialize replay descriptors
    158                 serialize(descriptors, descriptorFile.getAbsolutePath());
     169                serialize(descriptorsByPath, descriptorFile.getAbsolutePath());
    159170        }
    160171
     
    162173        public int size() {
    163174                initDescriptorCache();
    164                 return descriptors.size();
     175                return descriptorsByPath.size();
    165176        }
    166177
     
    200211
    201212        /**
    202          * Returns the path to file where the specified replay is serialized,
     213         * Returns the path to the file where an object is serialized.
    203214         * @param storageDir Directory containing the serialized objects.
    204          * @param replayFile File of the unparsed replay.
    205          * @return Path to serialized replay.
     215         * @param targetFile File of the object.
     216         * @return Path to serialized object.
    206217         */
    207218        protected static String getSerializationPath(File storageDir, File targetFile) {
  • src/main/java/de/erichseifert/warp/replays/sc2replay/SC2Replay_v2.java

    r9f43973 r0438dfb  
    5252                addVersionSupport(SC2Replay_v2.class, "0.12.0.15133");
    5353                addVersionSupport(SC2Replay_v2.class, "0.13.0.15250");
     54                addVersionSupport(SC2Replay_v2.class, "0.14.0.15343");
    5455                addVersionSupport(SC2Replay_v2.class, "0.14.0.15392");
    5556                addVersionSupport(SC2Replay_v2.class, "0.14.1.15392");
Note: See TracChangeset for help on using the changeset viewer.