Changeset 634d3c5


Ignore:
Timestamp:
Jun 11, 2010, 7:34:56 PM (10 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
84da366
Parents:
3a1f9ee
Message:

Parser replays load faster on startup;

BufferedStorage? no longer caches replay descriptors;

Moved some attributes of replays to ReplayDescriptor?

Location:
src/main/java/de/erichseifert/warp
Files:
11 edited

Legend:

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

    r3a1f9ee r634d3c5  
    3434public class DefaultReplay extends DefaultVersionedComponent implements Replay {
    3535        private final List<Player> players;
    36         private final File file;
    37         private String version;
    38         private int duration;
     36        private final ReplayDescriptor descriptor;
    3937
    4038        /**
     
    4341         */
    4442        public DefaultReplay(File file) {
    45                 this.file = file;
     43                descriptor = new ReplayDescriptor(file);
    4644                players = new ArrayList<Player>();
    47         }
    48 
    49         @Override
    50         public int getDuration() {
    51                 return duration;
    52         }
    53 
    54         /**
    55          * Sets the duration of the replay to the specified value.
    56          * @param duration Duration in milliseconds.
    57          */
    58         public void setDuration(int duration) {
    59                 this.duration = duration;
    60         }
    61 
    62         @Override
    63         public File getFile() {
    64                 return file;
    6545        }
    6646
     
    9878
    9979        @Override
    100         public String getVersion() {
    101                 return version;
    102         }
    103 
    104         /**
    105          * Sets the replay version to the specified version string.
    106          * @param version Version string.
    107          */
    108         public void setVersion(String version) {
    109                 this.version = version;
    110         }
    111 
    112         @Override
    11380        public ReplayDescriptor getDescriptor() {
    114                 return new ReplayDescriptor(getFile(), getDuration(), getVersion());
     81                return descriptor;
    11582        }
    11683}
  • src/main/java/de/erichseifert/warp/Replay.java

    r3a1f9ee r634d3c5  
    2222package de.erichseifert.warp;
    2323
    24 import java.io.File;
    2524import java.io.Serializable;
    2625import java.util.List;
     
    3029 */
    3130public interface Replay extends VersionedComponent, Serializable {
    32         /**
    33          * Returns the game duration of the replay.
    34          * @return Game duration.
    35          */
    36         int getDuration();
    37 
    38         /**
    39          * Returns the version of the replay.
    40          * @return Game version.
    41          */
    42         String getVersion();
    43 
    4431        /**
    4532         * Returns the players in the replay.
     
    6249
    6350        /**
    64          * Returns the file represented by this replay.
    65          * @return Replay file.
     51         * Returns this replay's descriptor.
     52         * @return Replay descriptor.
    6653         */
    67         File getFile();
    68 
    6954        ReplayDescriptor getDescriptor();
    7055}
  • src/main/java/de/erichseifert/warp/ReplayDescriptor.java

    r3a1f9ee r634d3c5  
    22
    33import java.io.File;
     4import java.io.Serializable;
    45
    56/**
    67 * Class that represents the most basic information about a {@link Replay}.
    78 */
    8 public class ReplayDescriptor {
     9public class ReplayDescriptor implements Serializable {
    910        private final File file;
    10         private final long duration;
    11         private final String version;
     11        private int duration;
     12        private String version;
    1213
    1314        /**
    1415         * Creates a new <code>ReplayDescriptor</code> object of the specified
    15          * file, duration and version.
     16         * file.
    1617         * @param file File to replay.
    17          * @param duration Duration.
    18          * @param version Version.
    1918         */
    20         public ReplayDescriptor(File file, long duration, String version) {
     19        public ReplayDescriptor(File file) {
    2120                this.file = file;
    22                 this.duration = duration;
    23                 this.version = version;
    2421        }
    2522
     
    3633         * @return Duration.
    3734         */
    38         public long getDuration() {
     35        public int getDuration() {
    3936                return duration;
    4037        }
     
    4744                return version;
    4845        }
     46
     47        /**
     48         * Sets the duration of the replay.
     49         * @param duration Duration.
     50         */
     51        public void setDuration(int duration) {
     52                this.duration = duration;
     53        }
     54
     55        /**
     56         * Sets the version of the replay.
     57         * @param version Version string.
     58         */
     59        public void setVersion(String version) {
     60                this.version = version;
     61        }
    4962}
  • src/main/java/de/erichseifert/warp/gui/DefaultReplayRenderer.java

    r3a1f9ee r634d3c5  
    6868                        else {
    6969                                // FIXME: Handle unsingned value
    70                                 replayDescription.setText("Duration: "+gameDurationToString(replay.getDuration())+" minutes");
     70                                replayDescription.setText("Duration: "+gameDurationToString(replay.getDescriptor().getDuration())+" minutes");
    7171
    7272                                playerPanel = new JPanel(new GridLayout((int) Math.round(replay.getPlayerCount()/2.0), 2));
  • src/main/java/de/erichseifert/warp/gui/ReplayRowFilter.java

    r3a1f9ee r634d3c5  
    124124                                if (filterMode == FilterMode.FILE_NAME ||
    125125                                        filterMode == FilterMode.FILE_AND_PLAYER_NAME) {
    126                                         String pathRelative = FileUtil.getPathRelativeTo(parentDir, replay.getFile()).toLowerCase();
     126                                        String pathRelative = FileUtil.getPathRelativeTo(parentDir, replay.getDescriptor().getFile()).toLowerCase();
    127127                                        if (pathRelative.contains(filterText)) {
    128128                                                return true;
  • src/main/java/de/erichseifert/warp/gui/renderers/sc2replay/SC2ReplayRenderer.java

    r3a1f9ee r634d3c5  
    7272                        else {
    7373                                // FIXME: Handle unsingned value
    74                                 replayDescription.setText("Duration: "+gameDurationToString(replay.getDuration())+" minutes");
     74                                replayDescription.setText("Duration: "+gameDurationToString(replay.getDescriptor().getDuration())+" minutes");
    7575                                mapPreviewLabel.setIcon(replay.getMapPreview());
    7676
  • src/main/java/de/erichseifert/warp/io/BufferedStorage.java

    r3a1f9ee r634d3c5  
    22
    33import java.util.ArrayList;
    4 import java.util.Collections;
    5 import java.util.HashSet;
    64import java.util.LinkedHashMap;
    75import java.util.List;
     
    2119        private final ReplayStorage storage;
    2220        private final LinkedHashMap<String, Replay> replayBuffer;
    23         private final Set<ReplayDescriptor> descriptors;
    2421
    2522        /**
     
    6461                this.storage = storage;
    6562                replayBuffer = new StorageBuffer(bufferSize);
    66                 descriptors = new HashSet<ReplayDescriptor>();
    6763        }
    6864
    6965        @Override
    7066        public Set<ReplayDescriptor> getDescriptors() {
    71                 if (descriptors.size() != size()) {
    72                         descriptors.addAll(storage.getDescriptors());
    73                 }
    74                 return Collections.unmodifiableSet(descriptors);
     67                return storage.getDescriptors();
    7568        }
    7669
     
    9184        @Override
    9285        public void save(Replay... replays) {
    93                 for (Replay replay : replays) {
    94                         descriptors.add(replay.getDescriptor());
    95                 }
    9686                storage.save(replays);
    9787        }
     
    10797        @Override
    10898        public void delete(Replay... replays) {
    109                 for (Replay replay : replays) {
    110                         descriptors.remove(replay);
    111                 }
    11299                storage.delete(replays);
    113100        }
  • src/main/java/de/erichseifert/warp/io/MemoryStorage.java

    r3a1f9ee r634d3c5  
    4747        public void save(Replay... replays) {
    4848                for (Replay replay : replays) {
    49                         cache.put(replay.getFile().getAbsolutePath(), replay);
     49                        cache.put(replay.getDescriptor().getFile().getAbsolutePath(), replay);
    5050                }
    5151        }
     
    5454        public void delete(Replay... replays) {
    5555                for (Replay replay : replays) {
    56                         cache.remove(replay.getFile().getAbsolutePath());
     56                        cache.remove(replay.getDescriptor().getFile().getAbsolutePath());
    5757                }
    5858        }
  • src/main/java/de/erichseifert/warp/io/SerializingStorage.java

    r3a1f9ee r634d3c5  
    88import java.io.ObjectInputStream;
    99import java.io.ObjectOutputStream;
     10import java.util.Collections;
    1011import java.util.HashSet;
    1112import java.util.LinkedList;
     
    2324public class SerializingStorage implements ReplayStorage {
    2425        private static final String STORAGE_PATH_DEFAULT = "data";
     26        private static final String DESCRIPTOR_FILE_NAME = ".descriptors";
    2527
     28        private Set<ReplayDescriptor> descriptors;
    2629        private File storageDir;
     30        private File descriptorFile;
    2731
    2832        /**
     
    4246        public SerializingStorage(String storagePath) {
    4347                storageDir = new File(storagePath);
     48                descriptorFile = new File(storagePath+File.separator+DESCRIPTOR_FILE_NAME);
    4449        }
    4550
     
    5055                        File replayFile = new File(path);
    5156                        String replayFilePath = getSerializationPath(storageDir, replayFile);
    52                         Replay replay = deserialize(replayFilePath);
     57                        Replay replay = (Replay) deserialize(replayFilePath);
    5358                        replays.add(replay);
    5459                }
     
    6166         * @return Deserialized replay.
    6267         */
    63         private static Replay deserialize(String pathSer) {
    64                 Replay replay = null;
     68        private static Object deserialize(String pathSer) {
     69                Object obj = null;
    6570                FileInputStream fis = null;
    6671                ObjectInputStream in = null;
     
    6873                        fis = new FileInputStream(pathSer);
    6974                        in = new ObjectInputStream(fis);
    70                         replay = (Replay) in.readObject();
     75                        obj = in.readObject();
    7176                } catch (FileNotFoundException e) {
    7277                        // TODO Auto-generated catch block
     
    9196                        }
    9297                }
    93                 return replay;
     98                return obj;
     99        }
     100
     101        private void initDescriptorCache() {
     102                if (descriptors != null) {
     103                        return;
     104                }
     105
     106                if (descriptorFile.exists()) {
     107                        descriptors = (Set<ReplayDescriptor>) deserialize(descriptorFile.getAbsolutePath());
     108                }
     109                else {
     110                        descriptors = new HashSet<ReplayDescriptor>();
     111                }
    94112        }
    95113
     
    100118                        storageDir.mkdir();
    101119                }
     120                initDescriptorCache();
    102121
     122                // Save replays
    103123                for (Replay replay : replays) {
    104                         String replayFilePath = getSerializationPath(storageDir, replay.getFile());
    105                         FileOutputStream fos = null;
    106                         ObjectOutputStream out = null;
    107                         try {
    108                                 fos = new FileOutputStream(replayFilePath);
    109                                 out = new ObjectOutputStream(fos);
     124                        String replayFilePath = getSerializationPath(storageDir, replay.getDescriptor().getFile());
     125                        serialize(replay, replayFilePath);
     126                        descriptors.add(replay.getDescriptor());
     127                }
    110128
    111                                 out.writeObject(replay);
    112                         } catch (FileNotFoundException e) {
    113                                 // TODO Auto-generated catch block
    114                                 e.printStackTrace();
    115                         } catch (IOException e) {
    116                                 // TODO Auto-generated catch block
    117                                 e.printStackTrace();
    118                         } finally {
    119                                 try {
    120                                         if (out != null) {
    121                                                 out.close();
    122                                         }
    123                                         if (out != null) {
    124                                                 fos.close();
    125                                         }
    126                                 } catch (IOException e) {
    127                                         // TODO Auto-generated catch block
    128                                         e.printStackTrace();
    129                                 }
    130                         }
    131                 }
     129                // Serialize replay descriptors
     130                serialize(descriptors, descriptorFile.getAbsolutePath());
    132131        }
    133132
    134133        @Override
    135134        public Set<ReplayDescriptor> getDescriptors() {
    136                 Set<ReplayDescriptor> descriptors = new HashSet<ReplayDescriptor>();
    137                 for (String replayPathSer : storageDir.list()) {
    138                         Replay replay = (Replay) deserialize(STORAGE_PATH_DEFAULT+File.separator+replayPathSer);
    139                         ReplayDescriptor descriptor = replay.getDescriptor();
    140                         descriptors.add(descriptor);
    141                 }
    142                 return descriptors;
     135                initDescriptorCache();
     136                return Collections.unmodifiableSet(descriptors);
    143137        }
    144138
    145139        @Override
    146140        public void delete(Replay... replays) {
     141                initDescriptorCache();
     142
    147143                for (Replay replay : replays) {
    148                         String serPath = getSerializationPath(storageDir, replay.getFile());
     144                        String serPath = getSerializationPath(storageDir, replay.getDescriptor().getFile());
    149145                        File serializedFile = new File(serPath);
    150146                        serializedFile.delete();
     147
     148                        descriptors.remove(replay.getDescriptor());
    151149                }
     150
     151                // Serialize replay descriptors
     152                serialize(descriptors, descriptorFile.getAbsolutePath());
    152153        }
    153154
    154155        @Override
    155156        public int size() {
    156                 // FIXME: Files that are contained in the storage directory but are no serialized replays count towards the element count
    157                 return storageDir.list().length;
     157                initDescriptorCache();
     158                return descriptors.size();
     159        }
     160
     161        private static void serialize(Object obj, String path) {
     162                FileOutputStream fos = null;
     163                ObjectOutputStream out = null;
     164                try {
     165                        fos = new FileOutputStream(path);
     166                        out = new ObjectOutputStream(fos);
     167
     168                        out.writeObject(obj);
     169                } catch (FileNotFoundException e) {
     170                        // TODO Auto-generated catch block
     171                        e.printStackTrace();
     172                } catch (IOException e) {
     173                        // TODO Auto-generated catch block
     174                        e.printStackTrace();
     175                } finally {
     176                        try {
     177                                if (out != null) {
     178                                        out.close();
     179                                }
     180                                if (out != null) {
     181                                        fos.close();
     182                                }
     183                        } catch (IOException e) {
     184                                // TODO Auto-generated catch block
     185                                e.printStackTrace();
     186                        }
     187                }
    158188        }
    159189
     
    164194         * @return Path to serialized replay.
    165195         */
    166         protected static String getSerializationPath(File storageDir, File replayFile) {
    167                 return storageDir.getAbsolutePath()+File.separator+FileUtil.fileHash(replayFile);
     196        protected static String getSerializationPath(File storageDir, File targetFile) {
     197                return storageDir.getAbsolutePath()+File.separator+FileUtil.fileHash(targetFile);
    168198        }
    169199}
  • src/main/java/de/erichseifert/warp/replays/sc2replay/SC2Replay_v1.java

    r3a1f9ee r634d3c5  
    8080                src.position(src.position()+39);
    8181                String version = src.get()+"."+src.get()+"."+src.get()+"."+src.getInt();
    82                 setVersion(version);
     82                getDescriptor().setVersion(version);
    8383                if (!isVersionSupported(getClass(), version)) {
    8484                        throw new IllegalArgumentException("Unsupported version: "+version);
    8585                }
    8686                src.position(src.position()+6);
    87                 setDuration(src.getShort());
     87                getDescriptor().setDuration(src.getShort());
    8888
    8989                System.out.println("Parsing file: "+file.getPath()+" Version: "+version);
     
    133133                if (obj != null && obj instanceof SC2Replay) {
    134134                        SC2Replay replayObj = (SC2Replay) obj;
    135                         return getFile().getPath().equals(replayObj.getFile());
     135                        return getDescriptor().getFile().getPath().equals(replayObj.getDescriptor().getFile());
    136136                }
    137137                return super.equals(obj);
  • src/main/java/de/erichseifert/warp/replays/sc2replay/SC2Replay_v2.java

    r3a1f9ee r634d3c5  
    7979                src.position(src.position()+39);
    8080                String version = src.get()+"."+src.get()+"."+src.get()+"."+src.getInt();
    81                 setVersion(version);
     81                getDescriptor().setVersion(version);
    8282                if (!isVersionSupported(getClass(), version)) {
    8383                        throw new IllegalArgumentException("Unsupported version: "+version);
    8484                }
    8585                src.position(src.position()+6);
    86                 setDuration(src.getShort());
     86                getDescriptor().setDuration(src.getShort());
    8787
    8888                System.out.println("Parsing file: "+file.getPath()+" Version: "+version);
     
    168168                if (obj != null && obj instanceof SC2Replay_v2) {
    169169                        SC2Replay_v2 replayObj = (SC2Replay_v2) obj;
    170                         return getFile().getPath().equals(replayObj.getFile());
     170                        return getDescriptor().getFile().getPath().equals(replayObj.getDescriptor().getFile());
    171171                }
    172172                return super.equals(obj);
Note: See TracChangeset for help on using the changeset viewer.