Changeset 70b8949


Ignore:
Timestamp:
Jul 12, 2010, 12:13:33 PM (8 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
39730c4
Parents:
cf52b31
Message:

Changed the load function of ReplayStorage? to return the descriptor instead of the replay itself;

Significantly sped up the searching process;

Added license headers

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

Legend:

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

    rcf52b31 r70b8949  
    152152        /**
    153153         * Returns a parsed replay with the specified file path.
    154          * @param id Id of the replay.
     154         * @param descriptor Descriptor of the replay.
    155155         * @return Parsed replay.
    156156         */
    157         public Replay getReplay(long id) {
    158                 return storage.load(id).get(0);
     157        public Replay getReplay(ReplayDescriptor descriptor) {
     158                return storage.getReplay(descriptor);
    159159        }
    160160
  • src/main/java/de/erichseifert/warp/gui/ReplayParserGUI.java

    rcf52b31 r70b8949  
    353353                                                // FIXME: Renderer should be retrieved by a factory
    354354                                                ReplayDescriptor replayDescriptor = (ReplayDescriptor) replayTable.getValueAt(selectedIndex, 0);
    355                                                 Replay replay = ReplayParserGUI.this.warp.getReplay(replayDescriptor.getId());
     355                                                Replay replay = ReplayParserGUI.this.warp.getReplay(replayDescriptor);
    356356                                                splitPane.setLeftComponent(replayRenderer.getRendererComponent((SC2Replay) replay));
    357357                                                // FIXME: Find better solution
  • src/main/java/de/erichseifert/warp/io/AbstractReplayStorage.java

    rcf52b31 r70b8949  
    4040        public void save(Replay... replays) {
    4141                for (Replay replay : replays) {
    42                         fireReplayDataChanged(null, replay.getDescriptor());
     42                        ReplayDescriptor descriptor = replay.getDescriptor();
     43                        fireReplayDataChanged(null, descriptor);
    4344                }
    4445        }
    4546
    4647        @Override
    47         public void delete(Replay... replays) {
    48                 for (Replay replay : replays) {
    49                         fireReplayDataChanged(replay.getDescriptor(), null);
     48        public void delete(long... ids) {
     49                for (long id : ids) {
     50                        ReplayDescriptor descriptorOld = load(id).get(0);
     51                        fireReplayDataChanged(descriptorOld, null);
    5052                }
    5153        }
  • src/main/java/de/erichseifert/warp/io/BufferedStorage.java

    rcf52b31 r70b8949  
    2323
    2424import java.io.File;
    25 import java.util.ArrayList;
    2625import java.util.LinkedHashMap;
    2726import java.util.List;
     
    9796
    9897        @Override
    99         public List<? extends Replay> load(long... ids) {
    100                 List<Replay> replays = new ArrayList<Replay>(ids.length);
    101                 for (long id : ids) {
    102                         Replay replay = replayBuffer.get(id);
    103                         if (replay == null) {
    104                                 replay = storage.load(id).get(0);
    105                         }
    106                         replayBuffer.put(id, replay);
    107                         replays.add(replay);
    108                 }
    109                 return replays;
     98        public List<ReplayDescriptor> load(long... ids) {
     99                return storage.load(ids);
    110100        }
    111101
     
    124114
    125115        @Override
    126         public void delete(Replay... replays) {
    127                 storage.delete(replays);
     116        public void delete(long... ids) {
     117                storage.delete(ids);
    128118        }
    129119
     
    160150                }
    161151        }
     152
     153        @Override
     154        public Replay getReplay(ReplayDescriptor descriptor) {
     155                long id = descriptor.getId();
     156                Replay replay = replayBuffer.get(id);
     157                if (replay == null) {
     158                        replay = storage.getReplay(descriptor);
     159                }
     160                replayBuffer.put(id, replay);
     161                return replay;
     162        }
    162163}
  • src/main/java/de/erichseifert/warp/io/MemoryStorage.java

    rcf52b31 r70b8949  
    2323
    2424import java.io.File;
    25 import java.util.ArrayList;
    2625import java.util.HashMap;
    2726import java.util.HashSet;
     27import java.util.LinkedList;
    2828import java.util.List;
    2929import java.util.Map;
     
    6060
    6161        @Override
    62         public List<? extends Replay> load(long... ids) {
    63                 List<Replay> replays = new ArrayList<Replay>(ids.length);
    64                 for (long id : ids) {
    65                         Replay replay = cache.get(id);
    66                         replays.add(replay);
    67                 }
    68                 return replays;
    69         }
    70 
    71         @Override
    7262        public void save(Replay... replays) {
    7363                for (Replay replay : replays) {
     
    7868
    7969        @Override
    80         public void delete(Replay... replays) {
    81                 for (Replay replay : replays) {
    82                         cache.remove(replay.getDescriptor().getId());
     70        public void delete(long... ids) {
     71                for (long id : ids) {
     72                        cache.remove(id);
    8373                }
    84                 super.delete(replays);
     74                super.delete(ids);
    8575        }
    8676
     
    9282        @Override
    9383        public boolean contains(File replayFile) {
    94                 return cache.containsValue(replayFile);
     84                for (Map.Entry<Long, Replay> entry : cache.entrySet()) {
     85                        Replay replay = entry.getValue();
     86                        if (replay.getDescriptor().getFile().getAbsolutePath().equals(replayFile.getAbsolutePath())) {
     87                                return true;
     88                        }
     89                }
     90                return false;
    9591        }
    9692
     
    112108                return null;
    113109        }
     110
     111        @Override
     112        public Replay getReplay(ReplayDescriptor descriptor) {
     113                long id = descriptor.getId();
     114                Replay replay = cache.get(id);
     115                return replay;
     116        }
     117
     118        @Override
     119        public List<ReplayDescriptor> load(long... ids) {
     120                List<ReplayDescriptor> descriptors = new LinkedList<ReplayDescriptor>();
     121                for (long id : ids) {
     122                        Replay replay = cache.get(id);
     123                        descriptors.add(replay.getDescriptor());
     124                }
     125                return descriptors;
     126        }
    114127}
  • src/main/java/de/erichseifert/warp/io/ReplayStorage.java

    rcf52b31 r70b8949  
    4242         * Returns the parsed replays which belong to the specified file paths.
    4343         * @param ids IDs of the unparsed replay files.
    44          * @return Parsed replays in the same order as the specified paths.
     44         * @return Descriptors of the parsed replays in the same order as the specified paths.
    4545         */
    46         List<? extends Replay> load(long... ids);
     46        List<ReplayDescriptor> load(long... ids);
    4747        /**
    4848         * Stores the specified replays.
     
    5252        /**
    5353         * Removes the specified replays.
    54          * @param replays Replays.
     54         * @param ids Replay ids.
    5555         */
    56         void delete(Replay... replays);
     56        void delete(long... ids);
     57
     58        Replay getReplay(ReplayDescriptor descriptor);
    5759
    5860        /**
     
    7678        /**
    7779         * Returns, whether the specified replay has already been stored or not.
    78          * @param replay File to the unparsed replay.
     80         * @param replayFile File to the unparsed replay.
    7981         * @return <code>true</code> if the replay already has been stored.
    8082         */
  • src/main/java/de/erichseifert/warp/io/SerializingStorage.java

    rcf52b31 r70b8949  
    6262        private Replay lastSavedReplay;
    6363
    64         private Map<String, ReplayDescriptor> descriptorsByPath;
     64        private Map<Long, ReplayDescriptor> descriptorsById;
    6565        private Statistics statistics;
    6666        private ReplayIndexer indexer;
     
    9292
    9393        @Override
    94         public List<? extends Replay> load(long... ids) {
    95                 List<Replay> replays = new LinkedList<Replay>();
    96                 for (long id : ids) {
    97                         // Check, if the requested replay can be retrieved by the buffer
    98                         if (lastSavedReplay != null && lastSavedReplay.getDescriptor().getId() == id) {
    99                                 replays.add(lastSavedReplay);
    100                         }
    101                         else {
    102                                 String replayFilePath = getSerializationPath(storageDir, id);
    103                                 Replay replay = (Replay) deserialize(replayFilePath);
    104                                 replays.add(replay);
    105                         }
    106                 }
    107                 return replays;
     94        public Replay getReplay(ReplayDescriptor descriptor) {
     95                Replay replay = null;
     96                // Check, if the requested replay can be retrieved by the buffer
     97                if (lastSavedReplay != null && lastSavedReplay.getDescriptor().getId() == descriptor.getId()) {
     98                        replay = lastSavedReplay;
     99                }
     100                else {
     101                        String replayFilePath = getSerializationPath(storageDir, descriptor.getId());
     102                        replay = (Replay) deserialize(replayFilePath);
     103                }
     104                return replay;
    108105        }
    109106
     
    153150         */
    154151        private void initDescriptorCache() {
    155                 if (descriptorsByPath != null) {
     152                if (descriptorsById != null) {
    156153                        return;
    157154                }
    158155
    159156                if (descriptorFile.exists()) {
    160                         descriptorsByPath = (Map<String, ReplayDescriptor>) deserialize(descriptorFile.getAbsolutePath());
     157                        descriptorsById = (Map<Long, ReplayDescriptor>) deserialize(descriptorFile.getAbsolutePath());
    161158                }
    162159                else {
    163                         descriptorsByPath = new HashMap<String, ReplayDescriptor>();
     160                        descriptorsById = new HashMap<Long, ReplayDescriptor>();
    164161                }
    165162        }
     
    214211                        String replayFilePath = getSerializationPath(storageDir, replay.getDescriptor());
    215212                        serialize(replay, replayFilePath);
    216                         descriptorsByPath.put(replay.getDescriptor().getFile().getAbsolutePath(), replay.getDescriptor());
     213                        descriptorsById.put(replay.getDescriptor().getId(), replay.getDescriptor());
    217214                        lastSavedReplay = replay;
    218215                }
     
    221218
    222219                // Serialize replay descriptors
    223                 serialize(descriptorsByPath, descriptorFile.getAbsolutePath());
     220                serialize(descriptorsById, descriptorFile.getAbsolutePath());
    224221
    225222                // Serialize statistics
     
    233230        public boolean contains(File replayFile) {
    234231                initDescriptorCache();
    235                 if (descriptorsByPath.containsKey(replayFile.getAbsolutePath())) {
    236                         return true;
     232                for (ReplayDescriptor descriptor : descriptorsById.values()) {
     233                        if (descriptor.getFile().getAbsolutePath().equals(replayFile.getAbsolutePath())) {
     234                                return true;
     235                        }
    237236                }
    238237                return false;
     
    242241        public Set<ReplayDescriptor> getDescriptors() {
    243242                initDescriptorCache();
    244                 return new HashSet<ReplayDescriptor>(descriptorsByPath.values());
    245         }
    246 
    247         @Override
    248         public void delete(Replay... replays) {
     243                return new HashSet<ReplayDescriptor>(descriptorsById.values());
     244        }
     245
     246        @Override
     247        public void delete(long... ids) {
    249248                initDescriptorCache();
    250249                initStatistics();
    251250                initIndexer();
    252251
    253                 for (Replay replay : replays) {
    254                         String serPath = getSerializationPath(storageDir, replay.getDescriptor());
     252                for (long id : ids) {
     253                        ReplayDescriptor descriptor = load(id).get(0);
     254                        String serPath = getSerializationPath(storageDir, descriptor);
    255255                        File serializedFile = new File(serPath);
    256256                        serializedFile.delete();
    257257
    258                         descriptorsByPath.remove(replay.getDescriptor().getFile());
    259                 }
    260 
    261                 super.delete(replays);
     258                        descriptorsById.remove(descriptor.getId());
     259                }
     260
     261                super.delete(ids);
    262262
    263263                // Serialize replay descriptors
    264                 serialize(descriptorsByPath, descriptorFile.getAbsolutePath());
     264                serialize(descriptorsById, descriptorFile.getAbsolutePath());
    265265
    266266                // Serialize statistics
     
    274274        public int size() {
    275275                initDescriptorCache();
    276                 return descriptorsByPath.size();
     276                return descriptorsById.size();
    277277        }
    278278
     
    342342                return indexer.getIndexNames();
    343343        }
     344
     345        @Override
     346        public List<ReplayDescriptor> load(long... ids) {
     347                List<ReplayDescriptor> descriptors = new LinkedList<ReplayDescriptor>();
     348                for (long id : ids) {
     349                        ReplayDescriptor descriptor = descriptorsById.get(id);
     350                        descriptors.add(descriptor);
     351                }
     352                return descriptors;
     353        }
    344354}
  • src/main/java/de/erichseifert/warp/io/search/DefaultReplayIndexer.java

    rcf52b31 r70b8949  
    6767                if (evt.getType() == EventType.REMOVE || evt.getType() == EventType.CHANGE) {
    6868                        ReplayDescriptor descriptor = evt.getDescriptorOld();
    69                         Replay replay = storage.load(descriptor.getId()).get(0);
     69                        Replay replay = storage.getReplay(descriptor);
    7070                        //TODO removeIndex(replay);
    7171                }
    7272                if (evt.getType() == EventType.ADD || evt.getType() == EventType.CHANGE) {
    7373                        ReplayDescriptor descriptor = evt.getDescriptorNew();
    74                         Replay replay = storage.load(descriptor.getId()).get(0);
     74                        Replay replay = storage.getReplay(descriptor);
    7575                        try {
    7676                                createIndices(replay, null, 0);
     
    188188                                        // The parent element of an index hierarchy must be a replay
    189189                                        long replayID = resultHierarchy.getFirstElement().getId();
    190                                         Replay parentElement = storage.load(replayID).get(0);
    191                                         ReplayDescriptor descriptor = parentElement.getDescriptor();
     190                                        ReplayDescriptor descriptor = storage.load(replayID).get(0);
    192191                                        results.add(descriptor);
    193192                                }
     
    208207                for (IndexHierarchy.Entry entry : hierarchy) {
    209208                        if ("#replay".equals(entry.getPropertyGetterName())) {
    210                                 parentObj = storage.load(entry.getId()).get(0);
     209                                ReplayDescriptor descriptor = storage.load(entry.getId()).get(0);
     210                                parentObj = storage.getReplay(descriptor);
    211211                                continue;
    212212                        }
  • src/main/java/de/erichseifert/warp/io/search/IndexHierarchy.java

    rcf52b31 r70b8949  
     1/**
     2 * WARP: WARP is a Replay Manager for Java(R)
     3 *
     4 * (C) Copyright 2010-2010 Michael Seifert <michael.seifert[at]gmx.net>
     5 *
     6 * This file is part of WARP.
     7 *
     8 * WARP is free software: you can redistribute it and/or modify
     9 * it under the terms of the GNU General Public License as published by
     10 * the Free Software Foundation, either version 3 of the License, or
     11 * (at your option) any later version.
     12 *
     13 * WARP is distributed in the hope that it will be useful,
     14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 * GNU General Public License for more details.
     17 *
     18 * You should have received a copy of the GNU General Public License
     19 * along with WARP.  If not, see <http://www.gnu.org/licenses/>.
     20 */
     21
    122package de.erichseifert.warp.io.search;
    223
     
    2344                public long getId() {
    2445                        return id;
     46                }
     47
     48                @Override
     49                public String toString() {
     50                        return propertyGetterName+"="+id;
    2551                }
    2652        }
Note: See TracChangeset for help on using the changeset viewer.