/**
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Cellersion 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY CellIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.hbase.regionserver;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.classification.InterfaceAudience;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.NavigableSet;
import java.util.NavigableMap;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* CellFlatMap stores a constant number of elements and is immutable after creation stage.
* Being immutable, the CellFlatMap can be implemented as array.
* The actual array can be on- or off-heap and is implemented in concrete class derived from CellFlatMap.
* The CellFlatMap uses no synchronization primitives, it is assumed to be created by a
* single thread and then it can be read-only by multiple threads.
*
* The "flat" in the name, means that the memory layout of the Map is sequential array and thus
* requires less memory than ConcurrentSkipListMap.
*/
@InterfaceAudience.Private
public abstract class CellFlatMap implements NavigableMap<Cell,Cell> {
private static final Log LOG = LogFactory.getLog(CellFlatMap.class);
private final Comparator<? super Cell> comparator;
protected int minCellIdx = 0; // the index of the minimal cell (for sub-sets)
protected int maxCellIdx = 0; // the index of the cell after the maximal cell (for sub-sets)
private boolean descending = false;
/* C-tor */
public CellFlatMap(Comparator<? super Cell> comparator, int min, int max, boolean d){
this.comparator = comparator;
this.minCellIdx = min;
this.maxCellIdx = max;
this.descending = d;
}
/* Used for abstract CellFlatMap creation, implemented by derived class */
protected abstract CellFlatMap createSubCellFlatMap(int min, int max, boolean descending);
/* Returns the i-th cell in the cell block */
protected abstract Cell getCell(int i);
/**
* Binary search for a given key in between given boundaries of the array.
* Positive returned numbers mean the index.
* Negative returned numbers means the key not found.
*
* The absolute value of the output is the
* possible insert index for the searched key
*
* In twos-complement, (-1 * insertion point)-1 is the bitwise not of the insert point.
*
*
* @param needle The key to look for in all of the entries
* @return Same return value as Arrays.binarySearch.
*/
private int find(Cell needle) {
int begin = minCellIdx;
int end = maxCellIdx - 1;
while (begin <= end) {
int mid = (begin + end) >>> 1;
Cell midCell = getCell(mid);
int compareRes = comparator.compare(midCell, needle);
if (compareRes == 0) {
return mid; // 0 means equals. We found the key
}
// Key not found. Check the comparison results; reverse the meaning of
// the comparison in case the order is descending (using XOR)
if ((compareRes < 0) ^ descending) {
// midCell is less than needle so we need to look at farther up
begin = mid + 1;
} else {
// midCell is greater than needle so we need to look down
end = mid - 1;
}
}
return (-1 * begin)-1;
}
/**
* Get the index of the given anchor key for creating subsequent set.
* It doesn't matter whether the given key exists in the set or not.
* taking into consideration whether
* the key should be inclusive or exclusive.
*/
private int getValidIndex(Cell key, boolean inclusive, boolean tail) {
final int index = find(key);
// get the valid (positive) insertion point from the output of the find() method
int insertionPoint = index < 0 ? ~index : index;
// correct the insertion point in case the given anchor key DOES EXIST in the set
if (index >= 0) {
if ( descending && !(tail ^ inclusive)) {
// for the descending case
// if anchor for head set (tail=false) AND anchor is not inclusive -> move the insertion pt
// if anchor for tail set (tail=true) AND the keys is inclusive -> move the insertion point
// because the end index of a set is the index of the cell after the maximal cell
insertionPoint += 1;
} else if ( !descending && (tail ^ inclusive)) {
// for the ascending case
// if anchor for head set (tail=false) AND anchor is inclusive -> move the insertion point
// because the end index of a set is the index of the cell after the maximal cell
// if anchor for tail set (tail=true) AND the keys is not inclusive -> move the insertion pt
insertionPoint += 1;
}
}
// insert the insertion point into the valid range,
// as we may enlarge it too much in the above correction
return Math.min(Math.max(insertionPoint, minCellIdx), maxCellIdx);
}
@Override
public Comparator<? super Cell> comparator() {
return comparator;
}
@Override
public int size() {
return maxCellIdx-minCellIdx;
}
@Override
public boolean isEmpty() {
return ( size() == 0 );
}
// ---------------- Sub-Maps ----------------
@Override
public NavigableMap<Cell, Cell> subMap( Cell fromKey,
boolean fromInclusive,
Cell toKey,
boolean toInclusive) {
final int lessCellIndex = getValidIndex(fromKey, fromInclusive, true);
final int greaterCellIndex = getValidIndex(toKey, toInclusive, false);
if (descending) {
return createSubCellFlatMap(greaterCellIndex, lessCellIndex, descending);
} else {
return createSubCellFlatMap(lessCellIndex, greaterCellIndex, descending);
}
}
@Override
public NavigableMap<Cell, Cell> headMap(Cell toKey, boolean inclusive) {
if (descending) {
return createSubCellFlatMap(getValidIndex(toKey, inclusive, false), maxCellIdx, descending);
} else {
return createSubCellFlatMap(minCellIdx, getValidIndex(toKey, inclusive, false), descending);
}
}
@Override
public NavigableMap<Cell, Cell> tailMap(Cell fromKey, boolean inclusive) {
if (descending) {
return createSubCellFlatMap(minCellIdx, getValidIndex(fromKey, inclusive, true), descending);
} else {
return createSubCellFlatMap(getValidIndex(fromKey, inclusive, true), maxCellIdx, descending);
}
}
@Override
public NavigableMap<Cell, Cell> descendingMap() {
return createSubCellFlatMap(minCellIdx, maxCellIdx, true);
}
@Override
public NavigableMap<Cell, Cell> subMap(Cell k1, Cell k2) {
return this.subMap(k1, true, k2, true);
}
@Override
public NavigableMap<Cell, Cell> headMap(Cell k) {
return this.headMap(k, true);
}
@Override
public NavigableMap<Cell, Cell> tailMap(Cell k) {
return this.tailMap(k, true);
}
// -------------------------------- Key's getters --------------------------------
@Override
public Cell firstKey() {
if (isEmpty()) {
return null;
}
return descending ? getCell(maxCellIdx - 1) : getCell(minCellIdx);
}
@Override
public Cell lastKey() {
if (isEmpty()) {
return null;
}
return descending ? getCell(minCellIdx) : getCell(maxCellIdx - 1);
}
@Override
public Cell lowerKey(Cell k) {
if (isEmpty()) {
return null;
}
int index = find(k);
// If index>=0 there's a key exactly equal
index = (index>=0) ? index-1 : -(index);
return (index < minCellIdx || index >= maxCellIdx) ? null : getCell(index);
}
@Override
public Cell floorKey(Cell k) {
if (isEmpty()) {
return null;
}
int index = find(k);
index = (index>=0) ? index : -(index);
return (index < minCellIdx || index >= maxCellIdx) ? null : getCell(index);
}
@Override
public Cell ceilingKey(Cell k) {
if (isEmpty()) {
return null;
}
int index = find(k);
index = (index>=0) ? index : -(index)+1;
return (index < minCellIdx || index >= maxCellIdx) ? null : getCell(index);
}
@Override
public Cell higherKey(Cell k) {
if (isEmpty()) {
return null;
}
int index = find(k);
index = (index>=0) ? index+1 : -(index)+1;
return (index < minCellIdx || index >= maxCellIdx) ? null : getCell(index);
}
@Override
public boolean containsKey(Object o) {
int index = find((Cell) o);
return (index >= 0);
}
@Override
public boolean containsValue(Object o) { // use containsKey(Object o) instead
throw new UnsupportedOperationException("Use containsKey(Object o) instead");
}
@Override
public Cell get(Object o) {
int index = find((Cell) o);
return (index >= 0) ? getCell(index) : null;
}
// -------------------------------- Entry's getters --------------------------------
// all interfaces returning Entries are unsupported because we are dealing only with the keys
@Override
public Entry<Cell, Cell> lowerEntry(Cell k) {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> higherEntry(Cell k) {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> ceilingEntry(Cell k) {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> floorEntry(Cell k) {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> firstEntry() {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> lastEntry() {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> pollFirstEntry() {
throw new UnsupportedOperationException();
}
@Override
public Entry<Cell, Cell> pollLastEntry() {
throw new UnsupportedOperationException();
}
// -------------------------------- Updates --------------------------------
// All updating methods below are unsupported.
// Assuming an array of Cells will be allocated externally,
// fill up with Cells and provided in construction time.
// Later the structure is immutable.
@Override
public Cell put(Cell k, Cell v) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
@Override
public Cell remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public void putAll(Map<? extends Cell, ? extends Cell> map) {
throw new UnsupportedOperationException();
}
// -------------------------------- Sub-Sets --------------------------------
@Override
public NavigableSet<Cell> navigableKeySet() {
throw new UnsupportedOperationException();
}
@Override
public NavigableSet<Cell> descendingKeySet() {
throw new UnsupportedOperationException();
}
@Override
public NavigableSet<Cell> keySet() {
throw new UnsupportedOperationException();
}
@Override
public Collection<Cell> values() {
return new CellFlatMapCollection();
}
@Override
public Set<Entry<Cell, Cell>> entrySet() {
throw new UnsupportedOperationException();
}
// -------------------------------- Iterator K --------------------------------
private final class CellFlatMapIterator implements Iterator<Cell> {
int index;
private CellFlatMapIterator() {
index = descending ? maxCellIdx-1 : minCellIdx;
}
@Override
public boolean hasNext() {
return descending ? (index >= minCellIdx) : (index < maxCellIdx);
}
@Override
public Cell next() {
Cell result = getCell(index);
if (descending) {
index--;
} else {
index++;
}
return result;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
// -------------------------------- Collection --------------------------------
private final class CellFlatMapCollection implements Collection<Cell> {
@Override
public int size() {
return CellFlatMap.this.size();
}
@Override
public boolean isEmpty() {
return CellFlatMap.this.isEmpty();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
@Override
public boolean contains(Object o) {
return containsKey(o);
}
@Override
public Iterator<Cell> iterator() {
return new CellFlatMapIterator();
}
@Override
public Object[] toArray() {
throw new UnsupportedOperationException();
}
@Override
public <T> T[] toArray(T[] ts) {
throw new UnsupportedOperationException();
}
@Override
public boolean add(Cell k) {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(Collection<? extends Cell> collection) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection<?> collection) {
throw new UnsupportedOperationException();
}
}
}