ceph/src/rocksdb/java/src/main/java/org/rocksdb/AbstractComparatorJniBridge.java

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 package org.rocksdb;
   7
   8 import java.nio.ByteBuffer;
   9
  10 /**
  11  * This class is intentionally private,
  12  * it holds methods which are called
  13  * from C++ to interact with a Comparator
  14  * written in Java.
  15  *
  16  * Placing these bridge methods in this
  17  * class keeps the API of the
  18  * {@link org.rocksdb.AbstractComparator} clean.
  19  */
  20 class AbstractComparatorJniBridge {
  21
  22     /**
  23      * Only called from JNI.
  24      *
  25      * Simply a bridge to calling
  26      * {@link AbstractComparator#compare(ByteBuffer, ByteBuffer)},
  27      * which ensures that the byte buffer lengths are correct
  28      * before and after the call.
  29      *
  30      * @param comparator the comparator object on which to
  31      *     call {@link AbstractComparator#compare(ByteBuffer, ByteBuffer)}
  32      * @param a buffer access to first key
  33      * @param aLen the length of the a key,
  34      *     may be smaller than the buffer {@code a}
  35      * @param b buffer access to second key
  36      * @param bLen the length of the b key,
  37      *     may be smaller than the buffer {@code b}
  38      *
  39      * @return the result of the comparison
  40      */
  41     private static int compareInternal(
  42             final AbstractComparator comparator,
  43             final ByteBuffer a, final int aLen,
  44             final ByteBuffer b, final int bLen) {
  45         if (aLen != -1) {
  46             a.mark();
  47             a.limit(aLen);
  48         }
  49         if (bLen != -1) {
  50             b.mark();
  51             b.limit(bLen);
  52         }
  53
  54         final int c = comparator.compare(a, b);
  55
  56         if (aLen != -1) {
  57             a.reset();
  58         }
  59         if (bLen != -1) {
  60             b.reset();
  61         }
  62
  63         return c;
  64     }
  65
  66     /**
  67      * Only called from JNI.
  68      *
  69      * Simply a bridge to calling
  70      * {@link AbstractComparator#findShortestSeparator(ByteBuffer, ByteBuffer)},
  71      * which ensures that the byte buffer lengths are correct
  72      * before the call.
  73      *
  74      * @param comparator the comparator object on which to
  75      *     call {@link AbstractComparator#findShortestSeparator(ByteBuffer, ByteBuffer)}
  76      * @param start buffer access to the start key
  77      * @param startLen the length of the start key,
  78      *     may be smaller than the buffer {@code start}
  79      * @param limit buffer access to the limit key
  80      * @param limitLen the length of the limit key,
  81      *     may be smaller than the buffer {@code limit}
  82      *
  83      * @return either {@code startLen} if the start key is unchanged, otherwise
  84      *     the new length of the start key
  85      */
  86     private static int findShortestSeparatorInternal(
  87             final AbstractComparator comparator,
  88             final ByteBuffer start, final int startLen,
  89             final ByteBuffer limit, final int limitLen) {
  90         if (startLen != -1) {
  91             start.limit(startLen);
  92         }
  93         if (limitLen != -1) {
  94             limit.limit(limitLen);
  95         }
  96         comparator.findShortestSeparator(start, limit);
  97         return start.remaining();
  98     }
  99
 100     /**
 101      * Only called from JNI.
 102      *
 103      * Simply a bridge to calling
 104      * {@link AbstractComparator#findShortestSeparator(ByteBuffer, ByteBuffer)},
 105      * which ensures that the byte buffer length is correct
 106      * before the call.
 107      *
 108      * @param comparator the comparator object on which to
 109      *     call {@link AbstractComparator#findShortSuccessor(ByteBuffer)}
 110      * @param key buffer access to the key
 111      * @param keyLen the length of the key,
 112      *     may be smaller than the buffer {@code key}
 113      *
 114      * @return either keyLen if the key is unchanged, otherwise the new length of the key
 115      */
 116     private static int findShortSuccessorInternal(
 117             final AbstractComparator comparator,
 118             final ByteBuffer key, final int keyLen) {
 119         if (keyLen != -1) {
 120             key.limit(keyLen);
 121         }
 122         comparator.findShortSuccessor(key);
 123         return key.remaining();
 124     }
 125 }