Changeset 3d01ad8


Ignore:
Timestamp:
Jul 11, 2010, 3:40:29 PM (8 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
cf52b31
Parents:
a2b2088
Message:

Improved indexing framework to store hierarchical data;

Changed replay ids from a string representation of an md5 checksum to an adler32 long and adapted ReplayStorage? to the changes

Location:
src
Files:
1 added
2 deleted
16 edited
1 moved

Legend:

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

    ra2b2088 r3d01ad8  
    2828import de.erichseifert.warp.io.search.indices.FieldIndex;
    2929import de.erichseifert.warp.io.search.indices.FullTextIndex;
     30import de.erichseifert.warp.util.FileUtil;
    3031
    3132/**
     
    3637        private int duration;
    3738        private String version;
     39        private transient long id;
    3840
    3941        /**
     
    4446        public ReplayDescriptor(File file) {
    4547                this.file = file;
     48                id = FileUtil.fileHash(file);
    4649        }
    4750
     
    97100                return super.equals(obj);
    98101        }
     102
     103        /**
     104         * Returns this replay descriptor's id.
     105         * @return Id.
     106         */
     107        public long getId() {
     108                return id;
     109        }
    99110}
  • src/main/java/de/erichseifert/warp/WARP.java

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

    ra2b2088 r3d01ad8  
    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.getFile().getAbsolutePath());
     355                                                Replay replay = ReplayParserGUI.this.warp.getReplay(replayDescriptor.getId());
    356356                                                splitPane.setLeftComponent(replayRenderer.getRendererComponent((SC2Replay) replay));
    357357                                                // FIXME: Find better solution
  • src/main/java/de/erichseifert/warp/io/BufferedStorage.java

    ra2b2088 r3d01ad8  
    4545
    4646        private final ReplayStorage storage;
    47         private final LinkedHashMap<String, Replay> replayBuffer;
     47        private final LinkedHashMap<Long, Replay> replayBuffer;
    4848
    4949        /**
     
    5252         * number of elements.
    5353         */
    54         private static final class StorageBuffer extends LinkedHashMap<String, Replay> {
     54        private static final class StorageBuffer extends LinkedHashMap<Long, Replay> {
    5555                private final int bufferSize;
    5656
     
    6565
    6666                @Override
    67                 protected boolean removeEldestEntry(Map.Entry<String, Replay> eldest) {
     67                protected boolean removeEldestEntry(Map.Entry<Long, Replay> eldest) {
    6868                        return size() > bufferSize;
    6969                }
     
    9797
    9898        @Override
    99         public List<? extends Replay> load(String... paths) {
    100                 List<Replay> replays = new ArrayList<Replay>(paths.length);
    101                 for (String path : paths) {
    102                         Replay replay = replayBuffer.get(path);
     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);
    103103                        if (replay == null) {
    104                                 replay = storage.load(path).get(0);
     104                                replay = storage.load(id).get(0);
    105105                        }
    106                         replayBuffer.put(path, replay);
     106                        replayBuffer.put(id, replay);
    107107                        replays.add(replay);
    108108                }
  • src/main/java/de/erichseifert/warp/io/MemoryStorage.java

    ra2b2088 r3d01ad8  
    4040 */
    4141public class MemoryStorage extends AbstractReplayStorage {
    42         private final Map<String, Replay> cache;
     42        private final Map<Long, Replay> cache;
    4343
    4444        /**
     
    4646         */
    4747        public MemoryStorage() {
    48                 cache = new HashMap<String, Replay>();
     48                cache = new HashMap<Long, Replay>();
    4949        }
    5050
     
    6060
    6161        @Override
    62         public List<? extends Replay> load(String... paths) {
    63                 List<Replay> replays = new ArrayList<Replay>(paths.length);
    64                 for (String path : paths) {
    65                         Replay replay = cache.get(path);
     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);
    6666                        replays.add(replay);
    6767                }
     
    7272        public void save(Replay... replays) {
    7373                for (Replay replay : replays) {
    74                         cache.put(replay.getDescriptor().getFile().getAbsolutePath(), replay);
     74                        cache.put(replay.getDescriptor().getId(), replay);
    7575                }
    7676                super.save(replays);
     
    8080        public void delete(Replay... replays) {
    8181                for (Replay replay : replays) {
    82                         cache.remove(replay.getDescriptor().getFile().getAbsolutePath());
     82                        cache.remove(replay.getDescriptor().getId());
    8383                }
    8484                super.delete(replays);
  • src/main/java/de/erichseifert/warp/io/ReplayStorage.java

    ra2b2088 r3d01ad8  
    4141        /**
    4242         * Returns the parsed replays which belong to the specified file paths.
    43          * @param paths Paths of the unparsed replay files.
     43         * @param ids IDs of the unparsed replay files.
    4444         * @return Parsed replays in the same order as the specified paths.
    4545         */
    46         List<? extends Replay> load(String... paths);
     46        List<? extends Replay> load(long... ids);
    4747        /**
    4848         * Stores the specified replays.
  • src/main/java/de/erichseifert/warp/io/SerializingStorage.java

    ra2b2088 r3d01ad8  
    4444import de.erichseifert.warp.io.statistics.SC2Statistics;
    4545import de.erichseifert.warp.io.statistics.Statistics;
    46 import de.erichseifert.warp.util.FileUtil;
    4746
    4847/**
     
    9392
    9493        @Override
    95         public List<? extends Replay> load(String... paths) {
     94        public List<? extends Replay> load(long... ids) {
    9695                List<Replay> replays = new LinkedList<Replay>();
    97                 for (String path : paths) {
     96                for (long id : ids) {
    9897                        // Check, if the requested replay can be retrieved by the buffer
    99                         if (lastSavedReplay != null && lastSavedReplay.getDescriptor().getFile().getAbsolutePath().equals(path)) {
     98                        if (lastSavedReplay != null && lastSavedReplay.getDescriptor().getId() == id) {
    10099                                replays.add(lastSavedReplay);
    101100                        }
    102101                        else {
    103                                 File replayFile = new File(path);
    104                                 String replayFilePath = getSerializationPath(storageDir, replayFile);
     102                                String replayFilePath = getSerializationPath(storageDir, id);
    105103                                Replay replay = (Replay) deserialize(replayFilePath);
    106104                                replays.add(replay);
     
    193191                else {
    194192                        // FIXME: Type of indexer should be retrieved by a factory
    195                         indexer = new DefaultReplayIndexer();
    196                 }
    197 
    198                 addReplayDataChangeListener(indexer);
     193                        indexer = new DefaultReplayIndexer(this);
     194                }
     195
     196                indexer.setStorage(this);
    199197        }
    200198
     
    214212                                continue;
    215213                        }
    216                         String replayFilePath = getSerializationPath(storageDir, replay.getDescriptor().getFile());
     214                        String replayFilePath = getSerializationPath(storageDir, replay.getDescriptor());
    217215                        serialize(replay, replayFilePath);
    218216                        descriptorsByPath.put(replay.getDescriptor().getFile().getAbsolutePath(), replay.getDescriptor());
     
    254252
    255253                for (Replay replay : replays) {
    256                         String serPath = getSerializationPath(storageDir, replay.getDescriptor().getFile());
     254                        String serPath = getSerializationPath(storageDir, replay.getDescriptor());
    257255                        File serializedFile = new File(serPath);
    258256                        serializedFile.delete();
     
    316314         * Returns the path to the file where an object is serialized.
    317315         * @param storageDir Directory containing the serialized objects.
    318          * @param targetFile File of the object.
     316         * @param descriptor Replay descriptor.
    319317         * @return Path to serialized object.
    320318         */
    321         protected static String getSerializationPath(File storageDir, File targetFile) {
    322                 return storageDir.getAbsolutePath()+File.separator+FileUtil.fileHash(targetFile);
     319        protected static String getSerializationPath(File storageDir, ReplayDescriptor descriptor) {
     320                return storageDir.getAbsolutePath()+File.separator+descriptor.getId();
     321        }
     322
     323        protected static String getSerializationPath(File storageDir, long id) {
     324                return storageDir.getAbsolutePath()+File.separator+id;
    323325        }
    324326
  • src/main/java/de/erichseifert/warp/io/search/AbstractReplayIndexer.java

    ra2b2088 r3d01ad8  
    9797         * @throws NoSuchMethodException if the <code>Index</code> has no matching constructor.
    9898         */
    99         protected static Index createIndex(Class<? extends Index> indexClass, IndexedProperty property) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    100                 Constructor<? extends Index> constructor = indexClass.getConstructor(IndexedProperty.class);
    101                 Index index = constructor.newInstance(property);
     99        protected Index createIndex(Class<? extends Index> indexClass, IndexedProperty property) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
     100                Constructor<? extends Index> constructor = indexClass.getConstructor(ReplayIndexer.class, IndexedProperty.class);
     101                Index index = constructor.newInstance(this, property);
    102102                return index;
    103103        }
  • src/main/java/de/erichseifert/warp/io/search/DefaultReplayIndexer.java

    ra2b2088 r3d01ad8  
    2727import java.util.HashMap;
    2828import java.util.HashSet;
    29 import java.util.LinkedList;
    30 import java.util.List;
     29import java.util.Iterator;
    3130import java.util.Map;
    3231import java.util.Set;
     
    5453public class DefaultReplayIndexer extends AbstractReplayIndexer {
    5554        private final Map<String, Index> indices;
     55        private transient ReplayStorage storage;
    5656
    5757        /**
    5858         * Creates a new <code>DefaultReplayIndexer</code> object.
    5959         */
    60         public DefaultReplayIndexer() {
     60        public DefaultReplayIndexer(ReplayStorage storage) {
    6161                indices = new HashMap<String, Index>();
    6262        }
     
    6767                if (evt.getType() == EventType.REMOVE || evt.getType() == EventType.CHANGE) {
    6868                        ReplayDescriptor descriptor = evt.getDescriptorOld();
    69                         Replay replay = storage.load(descriptor.getFile().getAbsolutePath()).get(0);
     69                        Replay replay = storage.load(descriptor.getId()).get(0);
    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.getFile().getAbsolutePath()).get(0);
     74                        Replay replay = storage.load(descriptor.getId()).get(0);
    7575                        try {
    76                                 createIndices(replay, null);
     76                                createIndices(replay, null, 0);
    7777                        } catch (IllegalArgumentException e) {
    7878                                // TODO Auto-generated catch block
     
    110110         * @param obj Object to be indexed.
    111111         * @param parents Hierarchy of nested properties.
     112         * @param id Id of the indexed object.
    112113         * @throws IllegalArgumentException
    113114         * @throws SecurityException
     
    119120         * @throws IntrospectionException
    120121         */
    121         private void createIndices(Object obj, List<Object> parents) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException, IntrospectionException {
     122        private void createIndices(Object obj, IndexHierarchy hierarchy, long listIndex) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException, IntrospectionException {
    122123                Map<IndexedProperty, Set<Indexable>> indexables = getIndexables(obj);
    123124
    124125                // Initialize hierarchy
    125                 if (parents == null) {
    126                         parents = new LinkedList<Object>();
    127                 }
    128                 // Add the currently indexed object to the parent hierarchy
    129                 parents.add(obj);
    130 
    131                 // Iterate over all indexed properties
    132                 for (Map.Entry<IndexedProperty, Set<Indexable>> entry : indexables.entrySet()) {
    133                         IndexedProperty property = entry.getKey();
    134                         Set<Indexable> indexableAnnotations = entry.getValue();
    135 
    136                         // Step into indexed children
    137                         if (property.isChildrenIndexed()) {
    138                                 Class<?> clazz = property.getDeclaringClass();
    139                                 Method getter = clazz.getMethod(property.getPropertyGetterName());
    140                                 Object indexedChild = getter.invoke(obj);
    141                                 // Check, if the indexed child is an iterable
    142                                 if (Iterable.class.isAssignableFrom(indexedChild.getClass())) {
    143                                         for (Object iterableChild : (Iterable<?>) indexedChild) {
    144                                                 createIndices(iterableChild, new LinkedList<Object>(parents));
     126                if (hierarchy == null) {
     127                        hierarchy = new IndexHierarchy();
     128                        if (obj instanceof Replay) {
     129                                hierarchy.put("#replay", ((Replay) obj).getDescriptor().getId());
     130                        }
     131                        // TODO: else throw exception
     132                }
     133
     134                // Check, if the indexed child is a list
     135                if (Iterable.class.isAssignableFrom(obj.getClass())) {
     136                        int position = 0;
     137                        for (Object iterableChild : (Iterable<?>) obj) {
     138                                IndexHierarchy iterableHierarchy = new IndexHierarchy(hierarchy);
     139                                iterableHierarchy.put("iterator", position);
     140                                createIndices(iterableChild, new IndexHierarchy(iterableHierarchy), 0);
     141                                position++;
     142                        }
     143                }
     144                else {
     145                        // Iterate over all indexed properties
     146                        for (Map.Entry<IndexedProperty, Set<Indexable>> entry : indexables.entrySet()) {
     147                                IndexHierarchy propertyBranch = new IndexHierarchy(hierarchy);
     148                                IndexedProperty property = entry.getKey();
     149                                Set<Indexable> indexableAnnotations = entry.getValue();
     150
     151                                // Add the currently indexed object to the parent hierarchy
     152                                propertyBranch.put(property.getPropertyGetterName(), listIndex);
     153
     154                                // Step into indexed children
     155                                if (property.isChildrenIndexed()) {
     156                                        Class<?> clazz = property.getDeclaringClass();
     157                                        Method getter = clazz.getMethod(property.getPropertyGetterName());
     158                                        Object indexedChild = getter.invoke(obj);
     159                                        createIndices(indexedChild, new IndexHierarchy(propertyBranch), 0);
     160                                }
     161
     162                                // Iterate of all Indexable annotations
     163                                for (Indexable indexable : indexableAnnotations) {
     164                                        String indexName = indexable.indexName();
     165                                        Index index = indices.get(indexName);
     166                                        if (index == null) {
     167                                                index = createIndex(indexable.indexClass(), property);
     168                                                indices.put(indexable.indexName(), index);
    145169                                        }
    146                                 }
    147                                 else {
    148                                         createIndices(indexedChild, new LinkedList<Object>(parents));
    149                                 }
    150                         }
    151 
    152                         // Iterate of all Indexable annotations
    153                         for (Indexable indexable : indexableAnnotations) {
    154                                 String indexName = indexable.indexName();
    155                                 Index index = indices.get(indexName);
    156                                 if (index == null) {
    157                                         index = createIndex(indexable.indexClass(), property);
    158                                         indices.put(indexable.indexName(), index);
    159                                 }
    160                                 index.index(parents);
     170                                        index.index(propertyBranch);
     171                                }
    161172                        }
    162173                }
     
    173184                        if (index != null) {
    174185                                Range range = ranges.get(indexName);
    175                                 Set<List<Object>> queryResults = index.search(queryValue, range);
    176                                 for (List<Object> resultHierarchy : queryResults) {
    177                                         Object parentElement = resultHierarchy.get(0);
    178                                         if (parentElement instanceof Replay) {
    179                                                 ReplayDescriptor descriptor = ((Replay) parentElement).getDescriptor();
    180                                                 results.add(descriptor);
    181                                         }
     186                                Set<IndexHierarchy> queryResults = index.search(queryValue, range);
     187                                for (IndexHierarchy resultHierarchy : queryResults) {
     188                                        // The parent element of an index hierarchy must be a replay
     189                                        long replayID = resultHierarchy.getFirstElement().getId();
     190                                        Replay parentElement = storage.load(replayID).get(0);
     191                                        ReplayDescriptor descriptor = parentElement.getDescriptor();
     192                                        results.add(descriptor);
    182193                                }
    183194                        }
     
    190201                return indices.keySet();
    191202        }
     203
     204        @Override
     205        public Object getChildObject(IndexHierarchy hierarchy) {
     206                Object parentObj = null;
     207                Object childObject = null;
     208                for (IndexHierarchy.Entry entry : hierarchy) {
     209                        if ("#replay".equals(entry.getPropertyGetterName())) {
     210                                parentObj = storage.load(entry.getId()).get(0);
     211                                continue;
     212                        }
     213                        childObject = null;
     214                        String getterName = entry.getPropertyGetterName();
     215                        long id = entry.getId();
     216                        Method getter = null;
     217                        try {
     218                                getter = parentObj.getClass().getMethod(getterName);
     219                        } catch (SecurityException e) {
     220                                // TODO Auto-generated catch block
     221                                e.printStackTrace();
     222                        } catch (NoSuchMethodException e) {
     223                                // TODO Auto-generated catch block
     224                                e.printStackTrace();
     225                        }
     226                        if (parentObj instanceof Iterable<?>) {
     227                                // Retrieve the iterator's element at the position specified by the id
     228                                Iterator<?> parentIterator = ((Iterable<?>) parentObj).iterator();
     229                                int position = 0;
     230                                while (position <= id) {
     231                                        childObject = parentIterator.next();
     232                                        position++;
     233                                }
     234                        }
     235                        else {
     236
     237                                try {
     238                                        childObject = getter.invoke(parentObj);
     239                                } catch (IllegalArgumentException e) {
     240                                        // TODO Auto-generated catch block
     241                                        e.printStackTrace();
     242                                } catch (IllegalAccessException e) {
     243                                        // TODO Auto-generated catch block
     244                                        e.printStackTrace();
     245                                } catch (InvocationTargetException e) {
     246                                        // TODO Auto-generated catch block
     247                                        e.printStackTrace();
     248                                }
     249                        }
     250                        parentObj = childObject;
     251                }
     252                return childObject;
     253        }
     254
     255        @Override
     256        public void setStorage(ReplayStorage storage) {
     257                if (this.storage != null) {
     258                        this.storage.removeReplayDataChangeListener(this);
     259                }
     260                this.storage = storage;
     261                if (this.storage != null) {
     262                        this.storage.addReplayDataChangeListener(this);
     263                }
     264        }
    192265}
  • src/main/java/de/erichseifert/warp/io/search/ReplayIndexer.java

    ra2b2088 r3d01ad8  
    2828import de.erichseifert.warp.ReplayDataChangeListener;
    2929import de.erichseifert.warp.ReplayDescriptor;
     30import de.erichseifert.warp.io.ReplayStorage;
    3031import de.erichseifert.warp.io.search.indices.Index.Range;
    3132
     
    7374         */
    7475        Set<String> getIndexNames();
     76
     77        Object getChildObject(IndexHierarchy hierarchy);
     78
     79        void setStorage(ReplayStorage storage);
    7580}
  • src/main/java/de/erichseifert/warp/io/search/indices/AbstractIndex.java

    ra2b2088 r3d01ad8  
    2222package de.erichseifert.warp.io.search.indices;
    2323
    24 import java.lang.reflect.InvocationTargetException;
    25 import java.lang.reflect.Method;
    2624import java.util.HashMap;
    2725import java.util.HashSet;
    28 import java.util.List;
    2926import java.util.Map;
    3027import java.util.Set;
    3128
     29import de.erichseifert.warp.io.search.IndexHierarchy;
    3230import de.erichseifert.warp.io.search.IndexedProperty;
     31import de.erichseifert.warp.io.search.ReplayIndexer;
    3332
    3433/**
     
    3837 */
    3938public abstract class AbstractIndex implements Index {
     39        private final ReplayIndexer indexer;
    4040        private final IndexedProperty property;
    41         private final Map<Object, Set<List<Object>>> indexedValues;
     41        private final Map<Object, Set<IndexHierarchy>> indexedValues;
    4242
    4343        /**
    4444         * Creates a new <code>AbstractIndex</code> object indexing the
    4545         * specified property.
     46         * @param indexer Indexer containing this index.
    4647         * @param property Property to be indexed.
    4748         */
    48         public AbstractIndex(IndexedProperty property) {
     49        public AbstractIndex(ReplayIndexer indexer, IndexedProperty property) {
     50                this.indexer = indexer;
    4951                this.property= property;
    50                 indexedValues = new HashMap<Object, Set<List<Object>>>();
     52                indexedValues = new HashMap<Object, Set<IndexHierarchy>>();
    5153        }
    5254
     
    5658         * @return Value of the property.
    5759         */
    58         protected Object getValue(List<Object> hierarchy) {
    59                 Method propertyGetter = property.getReadMethod();
    60                 Object value = null;
    61                 try {
    62                         Object childElement = hierarchy.get(hierarchy.size()-1);
    63                         value = propertyGetter.invoke(childElement);
    64                 } catch (IllegalArgumentException e) {
    65                         // TODO Auto-generated catch block
    66                         e.printStackTrace();
    67                 } catch (IllegalAccessException e) {
    68                         // TODO Auto-generated catch block
    69                         e.printStackTrace();
    70                 } catch (InvocationTargetException e) {
    71                         // TODO Auto-generated catch block
    72                         e.printStackTrace();
    73                 }
    74                 return value;
     60        protected Object getValue(IndexHierarchy hierarchy) {
     61                Object indexedObject = indexer.getChildObject(hierarchy);
     62                return indexedObject;
    7563        }
    7664
     
    8068         * @return Results.
    8169         */
    82         protected Set<List<Object>> get(Object value) {
     70        protected Set<IndexHierarchy> get(Object value) {
    8371                return indexedValues.get(value);
    8472        }
     
    8977         * @param hierarchy Indexing hierarchy.
    9078         */
    91         protected void put(Object value, List<Object> hierarchy) {
    92                 Set<List<Object>> hierarchies = indexedValues.get(value);
     79        protected void put(Object value, IndexHierarchy hierarchy) {
     80                Set<IndexHierarchy> hierarchies = indexedValues.get(value);
    9381                if (hierarchies == null) {
    94                         hierarchies = new HashSet<List<Object>>();
     82                        hierarchies = new HashSet<IndexHierarchy>();
    9583                        indexedValues.put(value, hierarchies);
    9684                }
     
    10492         * @param hierarchy Indexing hierarchy.
    10593         */
    106         protected void remove(Object value, List<Object> hierarchy) {
    107                 Set<List<Object>> hierarchies = indexedValues.get(value);
     94        protected void remove(Object value, IndexHierarchy hierarchy) {
     95                Set<IndexHierarchy> hierarchies = indexedValues.get(value);
    10896                if (hierarchies == null) {
    10997                        return;
     
    128116         */
    129117        public boolean contains(Object value) {
    130                 Set<List<Object>> hierarchies = indexedValues.get(value);
     118                Set<IndexHierarchy> hierarchies = indexedValues.get(value);
    131119                if (hierarchies == null) {
    132120                        return false;
     
    146134         * @return Entry set.
    147135         */
    148         protected Set<Map.Entry<Object, Set<List<Object>>>> entrySet() {
     136        protected Set<Map.Entry<Object, Set<IndexHierarchy>>> entrySet() {
    149137                return indexedValues.entrySet();
    150138        }
  • src/main/java/de/erichseifert/warp/io/search/indices/FieldIndex.java

    ra2b2088 r3d01ad8  
    2424import java.util.Collections;
    2525import java.util.HashSet;
    26 import java.util.List;
    2726import java.util.Map;
    2827import java.util.Set;
    2928
     29import de.erichseifert.warp.io.search.IndexHierarchy;
    3030import de.erichseifert.warp.io.search.IndexedProperty;
     31import de.erichseifert.warp.io.search.ReplayIndexer;
    3132
    3233/**
     
    4546         * Creates a new <code>FieldIndex</code> object indexing the specified
    4647         * property.
     48         * @param indexer Indexer containing this index.
    4749         * @param property Property to be indexed.
    4850         */
    49         public FieldIndex(IndexedProperty property) {
    50                 super(property);
     51        public FieldIndex(ReplayIndexer indexer, IndexedProperty property) {
     52                super(indexer, property);
    5153        }
    5254
    5355        @Override
    54         public void index(List<Object> hierarchy) {
     56        public void index(IndexHierarchy hierarchy) {
    5557                if (hierarchy == null) {
    5658                        return;
     
    6163
    6264        @Override
    63         public void unindex(List<Object> hierarchy) {
     65        public void unindex(IndexHierarchy hierarchy) {
    6466                if (hierarchy == null) {
    6567                        return;
     
    7072
    7173        @Override
    72         public boolean isIndexed(List<Object> hierarchy) {
     74        public boolean isIndexed(IndexHierarchy hierarchy) {
    7375                Object value = getValue(hierarchy);
    7476                return contains(value);
     
    7678
    7779        @Override
    78         public Set<List<Object>> search(Object query, Range range) {
    79                 Set<List<Object>> results;
     80        public Set<IndexHierarchy> search(Object query, Range range) {
     81                Set<IndexHierarchy> results;
    8082                if (query instanceof Comparable<?>) {
    81                         results = new HashSet<List<Object>>();
    82                         for (Map.Entry<Object, Set<List<Object>>> entry : entrySet()) {
     83                        results = new HashSet<IndexHierarchy>();
     84                        for (Map.Entry<Object, Set<IndexHierarchy>> entry : entrySet()) {
    8385                                Object key = entry.getKey();
    8486                                if (key instanceof Comparable<?>) {
  • src/main/java/de/erichseifert/warp/io/search/indices/FullTextIndex.java

    ra2b2088 r3d01ad8  
    2323
    2424import java.util.HashSet;
    25 import java.util.List;
    2625import java.util.Set;
    2726
     27import de.erichseifert.warp.io.search.IndexHierarchy;
    2828import de.erichseifert.warp.io.search.IndexedProperty;
     29import de.erichseifert.warp.io.search.ReplayIndexer;
    2930
    3031/**
     
    4546         * Creates a new <code>FullTextIndex</code> indexing the specified
    4647         * property.
     48         * @param indexer Indexer containing this index.
    4749         * @param property Property to be indexed.
    4850         */
    49         public FullTextIndex(IndexedProperty property) {
    50                 super(property);
     51        public FullTextIndex(ReplayIndexer indexer, IndexedProperty property) {
     52                super(indexer, property);
    5153                splitPattern = "\\W+";
    5254        }
     
    6567
    6668        @Override
    67         public void index(List<Object> hierarchy) {
     69        public void index(IndexHierarchy hierarchy) {
    6870                if (hierarchy == null) {
    6971                        return;
     
    7779
    7880        @Override
    79         public void unindex(List<Object> hierarchy) {
     81        public void unindex(IndexHierarchy hierarchy) {
    8082                if (hierarchy == null) {
    8183                        return;
     
    8991
    9092        @Override
    91         public boolean isIndexed(List<Object> hierarchy) {
     93        public boolean isIndexed(IndexHierarchy hierarchy) {
    9294                if (hierarchy == null) {
    9395                        return false;
     
    121123
    122124        @Override
    123         public Set<List<Object>> search(Object query, Range range) {
    124                 Set<List<Object>> results = new HashSet<List<Object>>();
     125        public Set<IndexHierarchy> search(Object query, Range range) {
     126                Set<IndexHierarchy> results = new HashSet<IndexHierarchy>();
    125127                String[] normalizedValue = normalize(query.toString());
    126128                for (String part : normalizedValue) {
    127                         Set<List<Object>> partResults = get(part);
     129                        Set<IndexHierarchy> partResults = get(part);
    128130                        if (partResults != null) {
    129131                                results.addAll(partResults);
  • src/main/java/de/erichseifert/warp/io/search/indices/Index.java

    ra2b2088 r3d01ad8  
    2323
    2424import java.io.Serializable;
    25 import java.util.List;
    2625import java.util.Set;
     26
     27import de.erichseifert.warp.io.search.IndexHierarchy;
    2728
    2829/**
     
    4849         * @param obj Object to be indexed.
    4950         */
    50         void index(List<Object> hierarchy);
     51        void index(IndexHierarchy hierarchy);
    5152        /**
    5253         * Removes the specified object from the index.
    5354         * @param obj Object to be removed from the index.
    5455         */
    55         void unindex(List<Object> hierarchy);
     56        void unindex(IndexHierarchy hierarchy);
    5657
    5758        /**
     
    6162         * @return Query results.
    6263         */
    63         Set<List<Object>> search(Object query, Range range);
     64        Set<IndexHierarchy> search(Object query, Range range);
    6465        /**
    6566         * Returns whether the specified object is stored or not stored in this
     
    6869         * @return <code>true</code>, if the object is indexed.
    6970         */
    70         boolean isIndexed(List<Object> hierarchy);
     71        boolean isIndexed(IndexHierarchy hierarchy);
    7172
    7273        /**
  • src/main/java/de/erichseifert/warp/util/FileUtil.java

    ra2b2088 r3d01ad8  
    2727import java.io.InputStream;
    2828import java.io.InputStreamReader;
    29 import java.math.BigInteger;
    30 import java.security.MessageDigest;
    31 import java.security.NoSuchAlgorithmException;
    3229import java.util.ArrayList;
    3330import java.util.Collection;
     
    3734import java.util.List;
    3835import java.util.Map;
     36import java.util.zip.Adler32;
     37import java.util.zip.Checksum;
    3938
    4039/**
     
    9594
    9695        /**
    97          * Creates a hash of 32 hex-digits from the specified file.
    98          * @param file File to use for hashing.
     96         * Creates a hash from the specified file.
     97         * @param file File used for hashing.
    9998         * @return Hash.
    10099         */
    101         public static String fileHash(File file) {
     100        public static long fileHash(File file) {
    102101                String path = file.getAbsolutePath();
    103 
    104                 MessageDigest algorithm = null;
    105                 try {
    106                         algorithm = MessageDigest.getInstance("MD5");
    107                 } catch (NoSuchAlgorithmException e) {
    108                         // TODO Auto-generated catch block
    109                         e.printStackTrace();
    110                 }
    111                 algorithm.update(path.getBytes());
    112                 BigInteger hashValue = new BigInteger(1, algorithm.digest());
    113                 return String.format("%1$032X", hashValue).toLowerCase();
     102                Checksum checksum = new Adler32();
     103                byte[] pathBytes = path.getBytes();
     104                checksum.update(pathBytes, 0, pathBytes.length);
     105                return checksum.getValue();
    114106        }
    115107
  • src/test/java/de/erichseifert/warp/io/search/indices/IndicesTests.java

    ra2b2088 r3d01ad8  
    2727@RunWith(Suite.class)
    2828@Suite.SuiteClasses({
    29         AbstractIndexTest.class,
    30         FullTextIndexTest.class
    3129})
    3230public class IndicesTests {
Note: See TracChangeset for help on using the changeset viewer.