Changeset 3a1f9ee


Ignore:
Timestamp:
Jun 11, 2010, 9:34:52 AM (10 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
634d3c5
Parents:
2a40525
Message:

Already saved replays are now loaded at program startup;

Improved ReplayStorage?;

Improved buffering of stored replays;

Added javadoc comments

Location:
src/main/java/de/erichseifert/warp
Files:
8 edited
1 moved

Legend:

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

    r2a40525 r3a1f9ee  
    11package de.erichseifert.warp;
    22
    3 import java.util.Collection;
    4 
     3/**
     4 * Interface that represents a listener for changes on replay data.
     5 */
    56public interface ReplayDataChangeListener {
    67
    7         void replaysAvailable(Collection<ReplayDescriptor> replayDescriptors);
     8        /**
     9         * This method is invoked when a replay was added or removed from the
     10         * data model.
     11         * @param descriptorOld Old descriptor.
     12         * @param descriptorNew New descriptor.
     13         */
     14        void replaysAvailable(ReplayDescriptor descriptorOld, ReplayDescriptor descriptorNew);
    815}
  • src/main/java/de/erichseifert/warp/ReplayDescriptor.java

    r2a40525 r3a1f9ee  
    33import java.io.File;
    44
     5/**
     6 * Class that represents the most basic information about a {@link Replay}.
     7 */
    58public class ReplayDescriptor {
    69        private final File file;
     
    811        private final String version;
    912
     13        /**
     14         * Creates a new <code>ReplayDescriptor</code> object of the specified
     15         * file, duration and version.
     16         * @param file File to replay.
     17         * @param duration Duration.
     18         * @param version Version.
     19         */
    1020        public ReplayDescriptor(File file, long duration, String version) {
    1121                this.file = file;
     
    1424        }
    1525
     26        /**
     27         * Returns the file of the replay.
     28         * @return File.
     29         */
    1630        public File getFile() {
    1731                return file;
    1832        }
    1933
     34        /**
     35         * Returns the duration of the replay.
     36         * @return Duration.
     37         */
    2038        public long getDuration() {
    2139                return duration;
    2240        }
    2341
     42        /**
     43         * Returns the version of the replay.
     44         * @return Version
     45         */
    2446        public String getVersion() {
    2547                return version;
  • src/main/java/de/erichseifert/warp/WARP.java

    r2a40525 r3a1f9ee  
    3939
    4040/**
    41  * Class that represents the main class of the replay parser.
     41 * Class that represents the supervising class of the replay parser.
     42 * It coordinates the data model and the user interface.
    4243 */
    4344public class WARP {
     
    5960                gui = new ReplayParserGUI(this);
    6061                gui.setVisible(true);
     62
     63                for (ReplayDescriptor descriptor : storage.getDescriptors()) {
     64                        fireReplayInfoChanged(null, descriptor);
     65                }
    6166        }
    6267
    6368        /**
    64          * @param args No arguments are processed.
     69         * @param args No command line arguments are processed.
    6570         */
    6671        public static void main(String[] args) {
     
    8388                new WARP();
    8489        }
    85 
     90        /**
     91         * Retrieves all supported replay files in the specified directory,
     92         * parses them, and adds them to the storage.
     93         * Calling this method fires a replay info change.
     94         * @param dir
     95         */
    8696        public void parseDir(File dir) {
    8797                if (dir == null) {
    8898                        return;
    8999                }
    90 
    91                 // FIXME: Do not delete all files. Check them for being up-to-date
    92                 //((SerializingStorage) storage).deleteAll();
    93100
    94101                // Store selected directory for the next startup
     
    99106                        Replay replay = ReplayParserFactory.getInstance().getReplayParser(replayFile);
    100107                        storage.save(replay);
     108
     109                        // Notify listeners
     110                        fireReplayInfoChanged(null, replay.getDescriptor());
    101111                }
    102112
    103                 // Notify listeners
    104                 fireReplayInfoChanged(storage.getDescriptors());
    105113
    106114                // FIXME: Find better solution
     
    109117        }
    110118
     119        /**
     120         * Returns a parsed replay with the specified file path.
     121         * @param path Path to replay file.
     122         * @return Parsed replay.
     123         */
    111124        public Replay getReplay(String path) {
    112125                return storage.load(path).get(0);
    113126        }
    114127
     128        /**
     129         * Registers the specified listener.
     130         * @param listener ReplayDataChangeListener.
     131         */
    115132        public void addDataChangeListener(ReplayDataChangeListener listener) {
    116133                listeners.add(listener);
    117134        }
    118135
     136        /**
     137         * Unregisters the specified listener.
     138         * @param listener ReplayDataChangeListener.
     139         */
    119140        public void removeDataChangeListener(ReplayDataChangeListener listener) {
    120141                listeners.remove(listener);
     
    123144        /**
    124145         * Notifies all listeners that new replay meta data is available.
    125          * @param replayDescriptors Replay descriptors.
     146         * @param descriptorsOld Replay descriptor of the old replay.
     147         * @param descriptorsNew Replay descriptor of the new/changed replay.
    126148         */
    127         protected void fireReplayInfoChanged(Collection<ReplayDescriptor> replayDescriptors) {
     149        protected void fireReplayInfoChanged(ReplayDescriptor descriptorOld, ReplayDescriptor descriptorNew) {
    128150                for (ReplayDataChangeListener listener : listeners) {
    129                         listener.replaysAvailable(replayDescriptors);
     151                        listener.replaysAvailable(descriptorOld, descriptorNew);
    130152                }
    131153        }
  • src/main/java/de/erichseifert/warp/gui/DefaultChatRenderer.java

    r2a40525 r3a1f9ee  
    4343
    4444        protected class DefaultChatComponent extends JPanel {
    45                 private final Collection<? extends Player> players;
    4645                private final JEditorPane messageDisplay;
    4746
    4847                protected DefaultChatComponent(Collection<? extends Player> players) {
    4948                        super(new BorderLayout());
    50                         this.players = players;
    5149
    5250                        messageDisplay = new JEditorPane();
  • src/main/java/de/erichseifert/warp/gui/ReplayParserGUI.java

    r2a40525 r3a1f9ee  
    3131import java.sql.Date;
    3232import java.text.DateFormat;
    33 import java.util.Collection;
    3433
    3534import javax.swing.AbstractAction;
     
    239238
    240239        @Override
    241         public void replaysAvailable(Collection<ReplayDescriptor> replayDescriptors) {
    242                 replayTableModel.setRowCount(0);
    243                 for (ReplayDescriptor replayDescriptor : replayDescriptors) {
    244                         replayTableModel.addRow(descriptorToRow(replayDescriptor));
     240        public void replaysAvailable(ReplayDescriptor descriptorOld, ReplayDescriptor descriptorNew) {
     241                if (descriptorOld == null && descriptorNew == null) {
     242                        return;
     243                }
     244
     245                // A replay has been added
     246                if (descriptorOld == null) {
     247                        replayTableModel.addRow(descriptorToRow(descriptorNew));
     248                } // A replay has been deleted
     249                else if (descriptorNew == null) {
     250                        for (int i = 0; i < replayTableModel.getRowCount(); i++) {
     251                                File replayFile = (File) replayTableModel.getValueAt(i, 0);
     252                                if (replayFile == descriptorOld.getFile()) {
     253                                        replayTableModel.removeRow(i);
     254                                        break;
     255                                }
     256                        }
    245257                }
    246258        }
  • src/main/java/de/erichseifert/warp/io/BufferedStorage.java

    r2a40525 r3a1f9ee  
    22
    33import java.util.ArrayList;
    4 import java.util.Collection;
     4import java.util.Collections;
     5import java.util.HashSet;
    56import java.util.LinkedHashMap;
    67import java.util.List;
    78import java.util.Map;
     9import java.util.Set;
    810
    911import de.erichseifert.warp.Replay;
     
    1820
    1921        private final ReplayStorage storage;
    20         private final LinkedHashMap<String, Replay> buffer;
     22        private final LinkedHashMap<String, Replay> replayBuffer;
     23        private final Set<ReplayDescriptor> descriptors;
    2124
     25        /**
     26         * Class that represents a buffer for this storage.
     27         * This buffer serves as a ring buffer (LIFO) with a specified maximum
     28         * number of elements.
     29         */
    2230        private static final class StorageBuffer extends LinkedHashMap<String, Replay> {
    2331                private final int bufferSize;
    2432
     33                /**
     34                 * Creates a new <code>StorageBuffer</code> with the specified buffer size.
     35                 * @param bufferSize
     36                 */
    2537                public StorageBuffer(int bufferSize) {
    2638                        super(bufferSize+1, 0.75f, true);
     
    5163        public BufferedStorage(ReplayStorage storage, int bufferSize) {
    5264                this.storage = storage;
    53                 buffer = new StorageBuffer(bufferSize);
     65                replayBuffer = new StorageBuffer(bufferSize);
     66                descriptors = new HashSet<ReplayDescriptor>();
    5467        }
    5568
    5669        @Override
    57         public Collection<ReplayDescriptor> getDescriptors() {
    58                 return storage.getDescriptors();
     70        public Set<ReplayDescriptor> getDescriptors() {
     71                if (descriptors.size() != size()) {
     72                        descriptors.addAll(storage.getDescriptors());
     73                }
     74                return Collections.unmodifiableSet(descriptors);
    5975        }
    6076
     
    6379                List<Replay> replays = new ArrayList<Replay>(paths.length);
    6480                for (String path : paths) {
    65                         Replay replay = buffer.get(path);
     81                        Replay replay = replayBuffer.get(path);
    6682                        if (replay == null) {
    6783                                replay = storage.load(path).get(0);
    6884                        }
    69                         buffer.put(path, replay);
     85                        replayBuffer.put(path, replay);
    7086                        replays.add(replay);
    7187                }
     
    7591        @Override
    7692        public void save(Replay... replays) {
     93                for (Replay replay : replays) {
     94                        descriptors.add(replay.getDescriptor());
     95                }
    7796                storage.save(replays);
    7897        }
     
    85104                return storage;
    86105        }
     106
     107        @Override
     108        public void delete(Replay... replays) {
     109                for (Replay replay : replays) {
     110                        descriptors.remove(replay);
     111                }
     112                storage.delete(replays);
     113        }
     114
     115        @Override
     116        public int size() {
     117                return storage.size();
     118        }
    87119}
  • src/main/java/de/erichseifert/warp/io/MemoryStorage.java

    r2a40525 r3a1f9ee  
    22
    33import java.util.ArrayList;
    4 import java.util.Collection;
    54import java.util.HashMap;
    65import java.util.HashSet;
    76import java.util.List;
    87import java.util.Map;
     8import java.util.Set;
    99
    1010import de.erichseifert.warp.Replay;
    1111import de.erichseifert.warp.ReplayDescriptor;
    1212
    13 public class CachingStorage implements ReplayStorage {
     13/**
     14 * Class that stores loaded replays in the memory.
     15 */
     16public class MemoryStorage implements ReplayStorage {
    1417        private final Map<String, Replay> cache;
    1518
    16         public CachingStorage() {
     19        /**
     20         * Creates a new <code>MemoryStorage</code> object.
     21         */
     22        public MemoryStorage() {
    1723                cache = new HashMap<String, Replay>();
    1824        }
    1925
    2026        @Override
    21         public Collection<ReplayDescriptor> getDescriptors() {
    22                 Collection<ReplayDescriptor> descriptors = new HashSet<ReplayDescriptor>();
     27        public Set<ReplayDescriptor> getDescriptors() {
     28                Set<ReplayDescriptor> descriptors = new HashSet<ReplayDescriptor>();
    2329                for (Replay replay : cache.values()) {
    2430                        ReplayDescriptor descriptor = replay.getDescriptor();
     
    4450                }
    4551        }
     52
     53        @Override
     54        public void delete(Replay... replays) {
     55                for (Replay replay : replays) {
     56                        cache.remove(replay.getFile().getAbsolutePath());
     57                }
     58        }
     59
     60        @Override
     61        public int size() {
     62                return cache.size();
     63        }
    4664}
  • src/main/java/de/erichseifert/warp/io/ReplayStorage.java

    r2a40525 r3a1f9ee  
    11package de.erichseifert.warp.io;
    22
    3 import java.util.Collection;
    43import java.util.List;
     4import java.util.Set;
    55
    66import de.erichseifert.warp.Replay;
    77import de.erichseifert.warp.ReplayDescriptor;
    88
     9/**
     10 * Interface that provides basic functions to store and load replays.
     11 */
    912public interface ReplayStorage {
    1013
     14        /**
     15         * Returns the parsed replays which belong to the specified file paths.
     16         * @param paths Paths of the unparsed replay files.
     17         * @return Parsed replays in the same order as the specified paths.
     18         */
    1119        List<? extends Replay> load(String... paths);
     20        /**
     21         * Stores the specified replays.
     22         * @param replays Replays to be stored.
     23         */
    1224        void save(Replay... replays);
     25        /**
     26         * Removes the specified replays.
     27         * @param replays Replays.
     28         */
     29        void delete(Replay... replays);
    1330
    14         Collection<ReplayDescriptor> getDescriptors();
     31        /**
     32         * Returns the descriptors of all stored replays.
     33         * The order of the retrieved descriptors depends on the implementation
     34         * of the respective implementation.
     35         * @return ReplayDescriptors.
     36         */
     37        Set<ReplayDescriptor> getDescriptors();
     38
     39        /**
     40         * Returns the number of stored elements.
     41         * @return Number of stored elements.
     42         */
     43        int size();
    1544}
  • src/main/java/de/erichseifert/warp/io/SerializingStorage.java

    r2a40525 r3a1f9ee  
    88import java.io.ObjectInputStream;
    99import java.io.ObjectOutputStream;
    10 import java.util.Collection;
     10import java.util.HashSet;
    1111import java.util.LinkedList;
    1212import java.util.List;
     13import java.util.Set;
    1314
    1415import de.erichseifert.warp.Replay;
     
    1617import de.erichseifert.warp.util.FileUtil;
    1718
     19/**
     20 * Class that serializes and deserializes all replays in order to store or
     21 * retrieve them.
     22 */
    1823public class SerializingStorage implements ReplayStorage {
    19         private static final String STORAGE_PATH = "data";
     24        private static final String STORAGE_PATH_DEFAULT = "data";
    2025
    2126        private File storageDir;
    2227
     28        /**
     29         * Creates a new <code>SerializingStorage</code> object with the
     30         * default storage path for serialized object.
     31         * The default storage path is \"data\".
     32         */
    2333        public SerializingStorage() {
    24                 storageDir = new File(STORAGE_PATH);
     34                this(STORAGE_PATH_DEFAULT);
     35        }
     36
     37        /**
     38         * Creates a new <code>SerializingStorage</code> object with the
     39         * specified storage path for serialized object.
     40         * @param storagePath Path to serialized objects.
     41         */
     42        public SerializingStorage(String storagePath) {
     43                storageDir = new File(storagePath);
    2544        }
    2645
     
    3049                for (String path : paths) {
    3150                        File replayFile = new File(path);
    32                         String replayFilePath = STORAGE_PATH+File.separator+FileUtil.fileHash(replayFile);
     51                        String replayFilePath = getSerializationPath(storageDir, replayFile);
    3352                        Replay replay = deserialize(replayFilePath);
    3453                        replays.add(replay);
     
    3756        }
    3857
     58        /**
     59         * Deserializes the object denoted by the specified path.
     60         * @param pathSer Path to the serialized object.
     61         * @return Deserialized replay.
     62         */
    3963        private static Replay deserialize(String pathSer) {
    4064                Replay replay = null;
     
    78102
    79103                for (Replay replay : replays) {
    80                         String replayFilePath = STORAGE_PATH+File.separator+FileUtil.fileHash(replay.getFile());
     104                        String replayFilePath = getSerializationPath(storageDir, replay.getFile());
    81105                        FileOutputStream fos = null;
    82106                        ObjectOutputStream out = null;
     
    108132        }
    109133
    110         public Collection<ReplayDescriptor> getDescriptors() {
    111                 Collection<ReplayDescriptor> descriptors = new LinkedList<ReplayDescriptor>();
     134        @Override
     135        public Set<ReplayDescriptor> getDescriptors() {
     136                Set<ReplayDescriptor> descriptors = new HashSet<ReplayDescriptor>();
    112137                for (String replayPathSer : storageDir.list()) {
    113                         Replay replay = (Replay) deserialize(STORAGE_PATH+File.separator+replayPathSer);
     138                        Replay replay = (Replay) deserialize(STORAGE_PATH_DEFAULT+File.separator+replayPathSer);
    114139                        ReplayDescriptor descriptor = replay.getDescriptor();
    115140                        descriptors.add(descriptor);
     
    118143        }
    119144
    120         public void deleteAll() {
    121                 storageDir.delete();
     145        @Override
     146        public void delete(Replay... replays) {
     147                for (Replay replay : replays) {
     148                        String serPath = getSerializationPath(storageDir, replay.getFile());
     149                        File serializedFile = new File(serPath);
     150                        serializedFile.delete();
     151                }
     152        }
     153
     154        @Override
     155        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;
     158        }
     159
     160        /**
     161         * Returns the path to file where the specified replay is serialized,
     162         * @param storageDir Directory containing the serialized objects.
     163         * @param replayFile File of the unparsed replay.
     164         * @return Path to serialized replay.
     165         */
     166        protected static String getSerializationPath(File storageDir, File replayFile) {
     167                return storageDir.getAbsolutePath()+File.separator+FileUtil.fileHash(replayFile);
    122168        }
    123169}
Note: See TracChangeset for help on using the changeset viewer.