@Override public V getValue() { final LinkEntry<K, V> current = currentEntry(); if (current == null) { throw new IllegalStateException(AbstractHashedMap.GETVALUE_INVALID); } return current.getValue(); }
@Override public K getKey() { final LinkEntry<K, V> current = currentEntry(); if (current == null) { throw new IllegalStateException(AbstractHashedMap.GETKEY_INVALID); } return current.getKey(); }
@Override public V setValue(final V value) { final LinkEntry<K, V> current = currentEntry(); if (current == null) { throw new IllegalStateException(AbstractHashedMap.SETVALUE_INVALID); } return current.setValue(value); } }
final FileObject file = linkEntry.getValue();
@Override protected boolean removeLRU(final AbstractLinkedMap.LinkEntry<FileName, FileObject> linkEntry) { synchronized (LRUFilesCache.this) { final FileObject file = linkEntry.getValue(); // System.err.println(">>> " + size() + " check removeLRU:" + linkEntry.getKey().toString()); if (file.isAttached() || file.isContentOpen()) { // do not allow open or attached files to be removed // System.err.println(">>> " + size() + " VETO removeLRU:" + // linkEntry.getKey().toString() + " (" + file.isAttached() + "/" + // file.isContentOpen() + ")"); return false; } // System.err.println(">>> " + size() + " removeLRU:" + linkEntry.getKey().toString()); if (super.removeLRU(linkEntry)) { try { // force detach file.close(); } catch (final FileSystemException e) { VfsLog.warn(getLogger(), log, Messages.getString("vfs.impl/LRUFilesCache-remove-ex.warn"), e); } final Map<?, ?> files = filesystemCache.get(filesystem); if (files.size() < 1) { filesystemCache.remove(filesystem); } return true; } return false; } } }
@Override protected boolean removeLRU(final AbstractLinkedMap.LinkEntry<FileName, FileObject> linkEntry) { synchronized (LRUFilesCache.this) { final FileObject file = linkEntry.getValue(); // System.err.println(">>> " + size() + " check removeLRU:" + linkEntry.getKey().toString()); if (file.isAttached() || file.isContentOpen()) { // do not allow open or attached files to be removed // System.err.println(">>> " + size() + " VETO removeLRU:" + // linkEntry.getKey().toString() + " (" + file.isAttached() + "/" + // file.isContentOpen() + ")"); return false; } // System.err.println(">>> " + size() + " removeLRU:" + linkEntry.getKey().toString()); if (super.removeLRU(linkEntry)) { try { // force detach file.close(); } catch (final FileSystemException e) { VfsLog.warn(getLogger(), log, Messages.getString("vfs.impl/LRUFilesCache-remove-ex.warn"), e); } final Map<?, ?> files = filesystemCache.get(filesystem); if (files.size() < 1) { filesystemCache.remove(filesystem); } return true; } return false; } } }
@Override protected boolean removeLRU(final AbstractLinkedMap.LinkEntry<FileName, FileObject> linkEntry) { synchronized (LRUFilesCache.this) { final FileObject file = linkEntry.getValue(); // System.err.println(">>> " + size() + " check removeLRU:" + linkEntry.getKey().toString()); if (file.isAttached() || file.isContentOpen()) { // do not allow open or attached files to be removed // System.err.println(">>> " + size() + " VETO removeLRU:" + // linkEntry.getKey().toString() + " (" + file.isAttached() + "/" + // file.isContentOpen() + ")"); return false; } // System.err.println(">>> " + size() + " removeLRU:" + linkEntry.getKey().toString()); if (super.removeLRU(linkEntry)) { try { // force detach file.close(); } catch (final FileSystemException e) { VfsLog.warn(getLogger(), log, Messages.getString("vfs.impl/LRUFilesCache-remove-ex.warn"), e); } final Map<?, ?> files = filesystemCache.get(filesystem); if (files.size() < 1) { filesystemCache.remove(filesystem); } return true; } return false; } } }
@Override public V list(final String afterObjectId, final Collection<V> outputBuffer, final int limit) { if(isEmpty()) { return null; } LinkEntry<K, V> nextEntry = getEntry(afterObjectId); for(int i = 0; i < limit; i++) { if(nextEntry == null) { nextEntry = getEntry(firstKey()); } else { nextEntry = entryAfter(nextEntry); } if(nextEntry == null || nextEntry.getKey() == null) { break; } outputBuffer.add(nextEntry.getValue()); } return (nextEntry == null || nextEntry.getKey() == null) ? null : nextEntry.getValue(); }
@Override protected boolean removeLRU(final LinkEntry<K, V> entry) { final V value = entry.getValue(); if (value != null && value instanceof Cachable) { ((Cachable)value).onRemoveFromCache(); } return true; } }
/** * Gets the value mapped to the key specified. * <p> * If {@code updateToMRU} is {@code true}, the position of the key in the map * is changed to the most recently used position (last), otherwise the iteration * order is not changed by this operation. * * @param key the key * @param updateToMRU whether the key shall be updated to the * most recently used position * @return the mapped value, null if no match * @since 4.1 */ public V get(final Object key, final boolean updateToMRU) { final LinkEntry<K, V> entry = getEntry(key); if (entry == null) { return null; } if (updateToMRU) { moveToMRU(entry); } return entry.getValue(); }
/** * Checks whether the map contains the specified value. * * @param value the value to search for * @return true if the map contains the value */ @Override public boolean containsValue(final Object value) { // override uses faster iterator if (value == null) { for (LinkEntry<K, V> entry = header.after; entry != header; entry = entry.after) { if (entry.getValue() == null) { return true; } } } else { for (LinkEntry<K, V> entry = header.after; entry != header; entry = entry.after) { if (isEqualValue(value, entry.getValue())) { return true; } } } return false; }
/** * Creates an entry to store the data. * <p> * This implementation creates a new LinkEntry instance. * * @param next the next entry in sequence * @param hashCode the hash code to use * @param key the key to store * @param value the value to store * @return the newly created entry */ @Override protected LinkEntry<K, V> createEntry(final HashEntry<K, V> next, final int hashCode, final K key, final V value) { return new LinkEntry<>(next, hashCode, convertKey(key), value); }
@Override public K next() { return super.nextEntry().getKey(); }
@Override public V next() { return super.nextEntry().getValue(); }
@Override public K previous() { return super.previousEntry().getKey(); }
/** * Gets the first key in the map, which is the first inserted. * * @return the eldest key */ @Override public K firstKey() { if (size == 0) { throw new NoSuchElementException("Map is empty"); } return header.after.getKey(); }
/** * Gets the key at the specified index. * * @param index the index to retrieve * @return the key at the specified index * @throws IndexOutOfBoundsException if the index is invalid */ public K get(final int index) { return getEntry(index).getKey(); }
@Override public V previous() { return super.previousEntry().getValue(); } }