@Override public final int compareKeyTo(byte[] rkey, int offset, int length) { if (offset != 0 || length != rkey.length) { byte[] newRkey = new byte[length]; System.arraycopy(rkey, offset, newRkey, 0, length); rkey = newRkey; } return mSource.compareKeyTo(mTransformer.inverseTransformKey(rkey)); }
@Override public byte[] exchange(final Transaction txn, final byte[] tkey, final byte[] tvalue) throws IOException { final byte[] key = inverseTransformKey(tkey); if (key == null) { throw fail(); } return mTransformer.transformValue (mSource.exchange(txn, key, mTransformer.inverseTransformValue(tvalue, key, tkey)), key, tkey); }
/** * Transform or filter out the given value. This method is only called when loading from a * positioned a cursor. Default implementation always forces the value to be loaded, unless * {@link #requireValue requireValue} returns false. * * @param cursor positioned cursor at the untransformed key and value (not null, might be * {@link Cursor#NOT_LOADED NOT_LOADED}) * @param tkey non-null transformed key associated with the value * @return transformed value or null to discard entry */ public default byte[] transformValue(Cursor cursor, byte[] tkey) throws IOException { byte[] value = cursor.value(); if (value == Cursor.NOT_LOADED && requireValue() != Boolean.FALSE) { cursor.load(); value = cursor.value(); } return transformValue(value, cursor.key(), tkey); }
byte[] tkey = mTransformer.transformKey(key, null); mKey = tkey; mValue = null; if (value == NOT_LOADED && mTransformer.requireValue()) { value = c.value(); byte[] tkey = mTransformer.transformKey(key, value); mKey = tkey; if (tkey != null) { byte[] tvalue = mTransformer.transformValue(value, key, tkey); if (tvalue != null) { mValue = tvalue;
@Override public void store(final Transaction txn, final byte[] tkey, final byte[] tvalue) throws IOException { final byte[] key = inverseTransformKey(tkey); if (key == null) { throw fail(); } mSource.store(txn, key, mTransformer.inverseTransformValue(tvalue, key, tkey)); }
@Override public View viewLe(byte[] tkey) { byte[] key = inverseTransformKey(tkey); if (key == null) { key = mTransformer.inverseTransformKeyLt(tkey); if (key == null) { return nonView(); } } return new TransformedView(mSource.viewLe(key), mTransformer); }
@Override public View viewGe(byte[] tkey) { byte[] key = inverseTransformKey(tkey); if (key == null) { key = mTransformer.inverseTransformKeyGt(tkey); if (key == null) { return nonView(); } } return new TransformedView(mSource.viewGe(key), mTransformer); }
lowKey = mTransformer.inverseTransformKeyGt(tprefix); if (lowKey == null) { return nonView(); byte[] highKey = inverseTransformKey(highTKey); if (highKey == null) { highKey = mTransformer.inverseTransformKeyLt(highTKey); if (highKey == null) { return nonView();
byte[] tkey = mTransformer.transformKey(c); mKey = tkey; byte[] tvalue = mTransformer.transformValue(c, tkey); if (tvalue != null) { mValue = tvalue;
@Override public Ordering getOrdering() { return mTransformer.transformedOrdering(mSource.getOrdering()); }
private LockFailureException transformCurrent(LockFailureException e) throws IOException { mValue = NOT_LOADED; try { mKey = mTransformer.transformKey(mSource); } catch (Throwable e2) { reset(); throw e2; } return e; }
@Override public long count(byte[] lowKey, byte[] highKey) throws IOException { return ViewUtils.count(this, mTransformer.requireValue(), lowKey, highKey); }
/** * @param tkey mKey must have been set to this non-null key already */ private LockResult transformCurrent(LockResult result, final byte[] tkey) throws IOException { final Cursor c = mSource; if (c.value() == null) { // Retain the position and lock when value doesn't exist. mValue = null; return result; } byte[] tvalue = mTransformer.transformValue(c, tkey); mValue = tvalue; if (tvalue == null && result == LockResult.ACQUIRED) { // Release the lock when filtered out, but maintain the cursor position. c.link().unlock(); result = LockResult.UNOWNED; } return result; }
@Override public Comparator<byte[]> getComparator() { return mTransformer.transformedComparator(mSource.getComparator()); }
byte[] tkey = mTransformer.transformKey(key, null); mKey = tkey; mValue = null; if (value == NOT_LOADED && mTransformer.requireValue()) { value = c.value(); byte[] tkey = mTransformer.transformKey(key, value); mKey = tkey; if (tkey != null) { byte[] tvalue = mTransformer.transformValue(value, key, tkey); if (tvalue != null) { mValue = tvalue;
@Override public void store(final Transaction txn, final byte[] tkey, final byte[] tvalue) throws IOException { final byte[] key = inverseTransformKey(tkey); if (key == null) { if (tvalue == null) { return; } throw fail(); } mSource.store(txn, key, mTransformer.inverseTransformValue(tvalue, key, tkey)); }
@Override public View viewLe(byte[] tkey) { byte[] key = inverseTransformKey(tkey); if (key == null) { key = mTransformer.inverseTransformKeyLt(tkey); if (key == null) { return nonView(); } } return new TransformedView(mSource.viewLe(key), mTransformer); }
@Override public View viewGe(byte[] tkey) { byte[] key = inverseTransformKey(tkey); if (key == null) { key = mTransformer.inverseTransformKeyGt(tkey); if (key == null) { return nonView(); } } return new TransformedView(mSource.viewGe(key), mTransformer); }
lowKey = mTransformer.inverseTransformKeyGt(tprefix); if (lowKey == null) { return nonView(); byte[] highKey = inverseTransformKey(highTKey); if (highKey == null) { highKey = mTransformer.inverseTransformKeyLt(highTKey); if (highKey == null) { return nonView();
@Override public Ordering getOrdering() { return mTransformer.transformedOrdering(mSource.getOrdering()); }