Uses of Interface
org.apache.hadoop.hbase.Cell

Packages that use Cell

Package	Description
org.apache.hadoop.hbase
org.apache.hadoop.hbase.backup.impl
org.apache.hadoop.hbase.backup.mapreduce
org.apache.hadoop.hbase.client	Provides HBase Client
org.apache.hadoop.hbase.client.coprocessor	Provides client classes for invoking Coprocessor RPC protocols Overview Example Usage
org.apache.hadoop.hbase.coprocessor	Table of Contents
org.apache.hadoop.hbase.coprocessor.example
org.apache.hadoop.hbase.coprocessor.example.row.stats
org.apache.hadoop.hbase.coprocessor.example.row.stats.utils
org.apache.hadoop.hbase.filter	Provides row-level filters applied to HRegion scan results during calls to ResultScanner.next().
org.apache.hadoop.hbase.io.encoding
org.apache.hadoop.hbase.io.hfile	Provides implementations of HFile and HFile BlockCache.
org.apache.hadoop.hbase.mapreduce	Provides HBase MapReduce Input/OutputFormats, a table indexing MapReduce job, and utility methods.
org.apache.hadoop.hbase.master.region
org.apache.hadoop.hbase.mob
org.apache.hadoop.hbase.procedure2.store.region
org.apache.hadoop.hbase.quotas
org.apache.hadoop.hbase.regionserver
org.apache.hadoop.hbase.regionserver.regionreplication
org.apache.hadoop.hbase.regionserver.throttle
org.apache.hadoop.hbase.regionserver.wal
org.apache.hadoop.hbase.replication	Multi Cluster Replication
org.apache.hadoop.hbase.replication.regionserver
org.apache.hadoop.hbase.rest	HBase REST
org.apache.hadoop.hbase.rest.model
org.apache.hadoop.hbase.security.access
org.apache.hadoop.hbase.security.visibility
org.apache.hadoop.hbase.thrift	Provides an HBase Thrift service.
org.apache.hadoop.hbase.thrift2	Provides an HBase Thrift service.
org.apache.hadoop.hbase.tool
org.apache.hadoop.hbase.util
org.apache.hadoop.hbase.wal

Uses of Cell in org.apache.hadoop.hbase

Subinterfaces of Cell in org.apache.hadoop.hbase

Modifier and Type	Interface	Description
interface	ExtendedCell	Extension to Cell with server side required functions.
interface	RawCell	An extended version of Cell that allows CPs manipulate Tags.

Classes in org.apache.hadoop.hbase that implement Cell

Modifier and Type	Class	Description
class	ByteBufferExtendedCell	This class is a server side extension to the Cell interface.
class	ByteBufferKeyOnlyKeyValue	This is a key only Cell implementation which is identical to KeyValue.KeyOnlyKeyValue with respect to key serialization but have its data in the form of Byte buffer (onheap and offheap).
class	ByteBufferKeyValue	This Cell is an implementation of ByteBufferExtendedCell where the data resides in off heap/ on heap ByteBuffer
class	IndividualBytesFieldCell
class	KeyValue	An HBase Key/Value.
static class	KeyValue.KeyOnlyKeyValue	A simple form of KeyValue that creates a keyvalue with only the key part of the byte[] Mainly used in places where we need to compare two cells.
class	NoTagsByteBufferKeyValue	An extension of the ByteBufferKeyValue where the tags length is always 0
class	NoTagsKeyValue	An extension of the KeyValue where the tags length is always 0
private static class	PrivateCellUtil.EmptyByteBufferExtendedCell	These cells are used in reseeks/seeks to improve the read performance.
private static class	PrivateCellUtil.EmptyCell	These cells are used in reseeks/seeks to improve the read performance.
private static class	PrivateCellUtil.FirstOnRowByteBufferExtendedCell
private static class	PrivateCellUtil.FirstOnRowCell
private static class	PrivateCellUtil.FirstOnRowColByteBufferExtendedCell
private static class	PrivateCellUtil.FirstOnRowColCell
private static class	PrivateCellUtil.FirstOnRowColTSByteBufferExtendedCell
private static class	PrivateCellUtil.FirstOnRowColTSCell
private static class	PrivateCellUtil.FirstOnRowDeleteFamilyCell
private static class	PrivateCellUtil.LastOnRowByteBufferExtendedCell
private static class	PrivateCellUtil.LastOnRowCell
private static class	PrivateCellUtil.LastOnRowColByteBufferExtendedCell
private static class	PrivateCellUtil.LastOnRowColCell
(package private) static class	PrivateCellUtil.TagRewriteByteBufferExtendedCell
(package private) static class	PrivateCellUtil.TagRewriteCell	This can be used when a Cell has to change with addition/removal of one or more tags.
(package private) static class	PrivateCellUtil.ValueAndTagRewriteByteBufferExtendedCell
(package private) static class	PrivateCellUtil.ValueAndTagRewriteCell
class	SizeCachedByteBufferKeyValue	This Cell is an implementation of ByteBufferExtendedCell where the data resides in off heap/ on heap ByteBuffer
class	SizeCachedKeyValue	This class is an extension to KeyValue where rowLen and keyLen are cached.
class	SizeCachedNoTagsByteBufferKeyValue	This Cell is an implementation of ByteBufferExtendedCell where the data resides in off heap/ on heap ByteBuffer
class	SizeCachedNoTagsKeyValue	This class is an extension to ContentSizeCachedKeyValue where there are no tags in Cell.

Methods in org.apache.hadoop.hbase that return Cell

Modifier and Type	Method	Description
Cell	CellBuilder.build()
static Cell	CellUtil.cloneIfNecessary(Cell cell)
static Cell	RawCell.createCell(Cell cell, List<Tag> tags)	Returns A new cell which is having the extra tags also added to it.
Cell	CellScanner.current()	Returns the current Cell which may be mutable

Methods in org.apache.hadoop.hbase that return types with arguments of type Cell

Modifier and Type	Method	Description
static List<Cell>	HBaseTestingUtility.getFromStoreFile(HStore store, byte[] row, NavigableSet<byte[]> columns)	Deprecated. Do a small get/scan against one store.
static List<Cell>	HBaseTestingUtility.getFromStoreFile(HStore store, Get get)	Deprecated. Do a small get/scan against one store.
Comparator<Cell>	CellComparator.getSimpleComparator()	Return a dumbed-down, fast comparator for hbase2 base-type, the ByteBufferKeyValue.
Comparator<Cell>	CellComparatorImpl.getSimpleComparator()

Methods in org.apache.hadoop.hbase with parameters of type Cell

Modifier and Type	Method	Description
static void	PerformanceEvaluationCommons.assertKey(byte[] expected, Cell c)
static byte[]	CellUtil.cloneFamily(Cell cell)
static Cell	CellUtil.cloneIfNecessary(Cell cell)
static byte[]	CellUtil.cloneQualifier(Cell cell)
static byte[]	CellUtil.cloneRow(Cell cell)	get individual arrays for tests
static byte[]	CellUtil.cloneValue(Cell cell)
int	CellComparator.compare(Cell leftCell, Cell rightCell)	Lexographically compares two cells.
int	CellComparator.compare(Cell leftCell, Cell rightCell, boolean ignoreSequenceid)	Compare cells.
final int	CellComparatorImpl.compare(Cell a, Cell b)
int	CellComparatorImpl.compare(Cell l, Cell r, boolean ignoreSequenceid)
int	MetaCellComparator.compare(Cell a, Cell b, boolean ignoreSequenceid)
private int	CellComparatorImpl.compareColumns(Cell left, int leftFamLen, int leftQualLen, Cell right, int rightFamLen, int rightQualLen)
final int	CellComparatorImpl.compareColumns(Cell left, Cell right)	Compares the family and qualifier part of the cell
static final int	CellUtil.compareColumns(Cell left, byte[] right, int rfoffset, int rflength, int rqoffset, int rqlength)	Compares the cell's column (family and qualifier) with the given byte[]
int	CellComparator.compareFamilies(Cell leftCell, Cell rightCell)	Lexicographically compares the families of the two cells
protected int	CellComparatorImpl.compareFamilies(Cell left, int leftFamLen, Cell right, int rightFamLen)	This method will be overridden when we compare cells inner store to bypass family comparing.
final int	CellComparatorImpl.compareFamilies(Cell left, Cell right)	Compare the families of left and right cell
static final int	CellUtil.compareFamilies(Cell left, byte[] right, int roffset, int rlength)	Compares the cell's family with the given byte[]
protected int	InnerStoreCellComparator.compareFamilies(Cell left, int leftFamilyLength, Cell right, int rightFamilyLength)
static int	PrivateCellUtil.compareFamily(Cell cell, ByteArrayComparable comparator)	Compare cell's column family against given comparator
static final int	PrivateCellUtil.compareKeyIgnoresMvcc(CellComparator comparator, Cell left, Cell right)	Compares only the key portion of a cell.
static int	PrivateCellUtil.compareQualifier(Cell cell, ByteArrayComparable comparator)	Compare cell's qualifier against given comparator
int	CellComparator.compareQualifiers(Cell leftCell, Cell rightCell)	Lexicographically compares the qualifiers of the two cells
private final int	CellComparatorImpl.compareQualifiers(Cell left, int leftQualLen, Cell right, int rightQualLen)
final int	CellComparatorImpl.compareQualifiers(Cell left, Cell right)	Compare the qualifiers part of the left and right cells.
static final int	CellUtil.compareQualifiers(Cell left, byte[] right, int rOffset, int rLength)	Compares the cell's qualifier with the given byte[]
static int	PrivateCellUtil.compareRow(Cell cell, ByteArrayComparable comparator)	Compare cell's row against given comparator
default int	CellComparator.compareRows(ByteBuffer row, Cell cell)	Lexicographically compare two rows
int	CellComparator.compareRows(Cell cell, byte[] bytes, int offset, int length)	Compares the row part of the cell with a simple plain byte[] like the stopRow in Scan.
int	CellComparator.compareRows(Cell leftCell, Cell rightCell)	Lexographically compares the rows of two cells.
int	CellComparatorImpl.compareRows(Cell left, byte[] right, int roffset, int rlength)	Compares the row part of the cell with a simple plain byte[] like the stopRow in Scan.
(package private) static int	CellComparatorImpl.compareRows(Cell left, int leftRowLength, Cell right, int rightRowLength)
int	CellComparatorImpl.compareRows(Cell left, Cell right)	Compares the rows of the left and right cell.
int	MetaCellComparator.compareRows(ByteBuffer row, Cell cell)
int	MetaCellComparator.compareRows(Cell left, byte[] right, int roffset, int rlength)
int	MetaCellComparator.compareRows(Cell left, Cell right)
int	CellComparator.compareTimestamps(Cell leftCell, Cell rightCell)	Compares cell's timestamps in DESCENDING order.
int	CellComparatorImpl.compareTimestamps(Cell left, Cell right)
static int	PrivateCellUtil.compareValue(Cell cell, ByteArrayComparable comparator)	Compare cell's value against given comparator
int	CellComparator.compareWithoutRow(Cell leftCell, Cell rightCell)	Lexicographically compares the two cells excluding the row part.
final int	CellComparatorImpl.compareWithoutRow(Cell left, Cell right)
static void	PrivateCellUtil.compressFamily(OutputStream out, Cell cell, Dictionary dict)
static void	PrivateCellUtil.compressQualifier(OutputStream out, Cell cell, Dictionary dict)
static void	PrivateCellUtil.compressRow(OutputStream out, Cell cell, Dictionary dict)
static int	CellUtil.copyFamilyTo(Cell cell, byte[] destination, int destinationOffset)	Copies the family to the given byte[]
static int	CellUtil.copyFamilyTo(Cell cell, ByteBuffer destination, int destinationOffset)	Copies the family to the given bytebuffer
static int	CellUtil.copyQualifierTo(Cell cell, byte[] destination, int destinationOffset)	Copies the qualifier to the given byte[]
static int	CellUtil.copyQualifierTo(Cell cell, ByteBuffer destination, int destinationOffset)	Copies the qualifier to the given bytebuffer
static byte[]	CellUtil.copyRow(Cell cell)	Copies the row to a new byte[]
static int	CellUtil.copyRowTo(Cell cell, byte[] destination, int destinationOffset)	Copies the row to the given byte[]
static int	CellUtil.copyRowTo(Cell cell, ByteBuffer destination, int destinationOffset)	Copies the row to the given bytebuffer
static int	CellUtil.copyValueTo(Cell cell, byte[] destination, int destinationOffset)	Copies the value to the given byte[]
static int	CellUtil.copyValueTo(Cell cell, ByteBuffer destination, int destinationOffset)	Copies the value to the given bytebuffer
static Cell	RawCell.createCell(Cell cell, List<Tag> tags)	Returns A new cell which is having the extra tags also added to it.
static CellScanner	CellUtil.createCellScanner(Cell[] cellArray)	Returns CellScanner interface over cellArray
static ExtendedCell	PrivateCellUtil.createFirstOnNextRow(Cell cell)
static ExtendedCell	PrivateCellUtil.createFirstOnRow(Cell cell)	Create a Cell that is smaller than all other possible Cells for the given Cell's row.
static ExtendedCell	PrivateCellUtil.createFirstOnRowCol(Cell cell)
static ExtendedCell	PrivateCellUtil.createFirstOnRowCol(Cell cell, byte[] qArray, int qoffest, int qlength)	Create a Cell that is smaller than all other possible Cells for the given Cell's rk:cf and passed qualifier.
static ExtendedCell	PrivateCellUtil.createFirstOnRowColTS(Cell cell, long ts)	Creates the first cell with the row/family/qualifier of this cell and the given timestamp.
static ExtendedCell	PrivateCellUtil.createFirstOnRowFamily(Cell cell, byte[] fArray, int foff, int flen)
static ExtendedCell	PrivateCellUtil.createLastOnRow(Cell cell)	Create a Cell that is larger than all other possible Cells for the given Cell's row.
static ExtendedCell	PrivateCellUtil.createLastOnRowCol(Cell cell)	Create a Cell that is larger than all other possible Cells for the given Cell's rk:cf:q.
static ExtendedCell	PrivateCellUtil.ensureExtendedCell(Cell cell)	In fact, in HBase, all Cells are ExtendedCells.
static boolean	CellUtil.equals(Cell a, Cell b)	equals
static int	PrivateCellUtil.estimatedSerializedSizeOf(Cell cell)	Estimate based on keyvalue's serialization format in the RPC layer.
static int	PrivateCellUtil.estimatedSerializedSizeOfKey(Cell cell)	Calculates the serialized key size.
static ByteRange	PrivateCellUtil.fillFamilyRange(Cell cell, ByteRange range)
static ByteRange	PrivateCellUtil.fillQualifierRange(Cell cell, ByteRange range)
static ByteRange	PrivateCellUtil.fillRowRange(Cell cell, ByteRange range)	ByteRange
static ByteRange	PrivateCellUtil.fillValueRange(Cell cell, ByteRange range)
static String	CellUtil.getCellKeyAsString(Cell cell)	Returns The Key portion of the passed cell as a String.
static String	CellUtil.getCellKeyAsString(Cell cell, Function<Cell,String> rowConverter)	Return the Key portion of the passed cell as a String.
static List<RegionInfo>	CatalogFamilyFormat.getMergeRegions(Cell[] cells)	Returns Deserialized regioninfo values taken from column values that match the regex 'info:merge.*' in array of cells.
static Map<String,RegionInfo>	CatalogFamilyFormat.getMergeRegionsWithName(Cell[] cells)	Returns Deserialized values of <qualifier,regioninfo> pairs taken from column values that match the regex 'info:merge.*' in array of cells.
static byte	PrivateCellUtil.getQualifierByte(Cell cell, int index)
static int	PrivateCellUtil.getRowAsInt(Cell cell)	Converts the rowkey bytes of the given cell into an int value
static byte	PrivateCellUtil.getRowByte(Cell cell, int index)	misc
static long	PrivateCellUtil.getSequenceId(Cell c)
static byte	PrivateCellUtil.getTypeByte(Cell c)
static BigDecimal	PrivateCellUtil.getValueAsBigDecimal(Cell cell)	Converts the value bytes of the given cell into a BigDecimal
static double	PrivateCellUtil.getValueAsDouble(Cell cell)	Converts the value bytes of the given cell into a double value
static int	PrivateCellUtil.getValueAsInt(Cell cell)	Converts the value bytes of the given cell into a int value
static long	PrivateCellUtil.getValueAsLong(Cell cell)	Converts the value bytes of the given cell into a long value
static ByteBuffer	PrivateCellUtil.getValueBufferShallowCopy(Cell cell)
static boolean	CatalogFamilyFormat.hasMergeRegions(Cell[] cells)	Returns True if any merge regions present in cells; i.e.
static boolean	CellUtil.isDelete(Cell cell)	Return true if a delete type, a KeyValue.Type.Delete or a {KeyValue.Type#DeleteFamily} or a KeyValue.Type.DeleteColumn KeyValue type.
static boolean	CatalogFamilyFormat.isMergeQualifierPrefix(Cell cell)	Returns True if the column in cell matches the regex 'info:merge.*'.
static boolean	CellUtil.isPut(Cell cell)	Returns True if this cell is a Put.
private boolean	HBaseTestingUtility.isTargetTable(byte[] inRow, Cell c)	Deprecated.
static int	KeyValueUtil.keyLength(Cell cell)	Returns number of bytes this cell's key part would have been used if serialized as in KeyValue.
static boolean	CellUtil.matchingColumn(Cell left, byte[] fam, byte[] qual)
private static boolean	CellUtil.matchingColumn(Cell left, byte lFamLen, int lQualLength, Cell right, byte rFamLen, int rQualLength)
static boolean	CellUtil.matchingColumn(Cell left, Cell right)
static boolean	PrivateCellUtil.matchingColumn(Cell left, byte[] fam, int foffset, int flength, byte[] qual, int qoffset, int qlength)
static boolean	CellUtil.matchingColumnFamilyAndQualifierPrefix(Cell left, byte[] fam, byte[] qual)	Returns True if matching column family and the qualifier starts with qual
static boolean	CellUtil.matchingFamily(Cell left, byte[] buf)
static boolean	CellUtil.matchingFamily(Cell left, byte lfamlength, Cell right, byte rfamlength)
static boolean	CellUtil.matchingFamily(Cell left, Cell right)
static boolean	PrivateCellUtil.matchingFamily(Cell left, byte[] buf, int offset, int length)
static boolean	CellUtil.matchingQualifier(Cell left, byte[] buf)	Finds if the qualifier part of the cell and the KV serialized byte[] are equal.
private static boolean	CellUtil.matchingQualifier(Cell left, int lqlength, Cell right, int rqlength)
static boolean	CellUtil.matchingQualifier(Cell left, Cell right)
static boolean	PrivateCellUtil.matchingQualifier(Cell left, byte[] buf, int offset, int length)	Finds if the qualifier part of the cell and the KV serialized byte[] are equal
static boolean	CellUtil.matchingRow(Cell left, byte[] buf, int offset, int length)
static boolean	CellUtil.matchingRowColumn(Cell left, Cell right)	Compares the row and column of two keyvalues for equality
static boolean	CellUtil.matchingRowColumnBytes(Cell left, Cell right)	Compares the row and column of two keyvalues for equality
static boolean	CellUtil.matchingRows(Cell left, byte[] buf)
static boolean	CellUtil.matchingRows(Cell left, short lrowlength, Cell right, short rrowlength)	Compares the row of two keyvalues for equality
static boolean	CellUtil.matchingRows(Cell left, Cell right)	Compares the row of two keyvalues for equality
static boolean	PrivateCellUtil.matchingRows(Cell left, byte[] buf, int offset, int length)
static boolean	CellUtil.matchingTags(Cell left, Cell right)	Deprecated. Since 3.0.0, will be removed in 4.0.0.
static boolean	CellUtil.matchingTimestamp(Cell a, Cell b)
static boolean	CellUtil.matchingValue(Cell left, byte[] buf)
static boolean	CellUtil.matchingValue(Cell left, Cell right)
static boolean	CellUtil.matchingValue(Cell left, Cell right, int lvlength, int rvlength)
static boolean	PrivateCellUtil.matchingValue(Cell left, Cell right, int lvlength, int rvlength)
static boolean	PrivateCellUtil.qualifierStartsWith(Cell left, byte[] startsWith)	Finds if the start of the qualifier part of the Cell matches buf
static void	PrivateCellUtil.setSequenceId(Cell cell, long seqId)	Sets the given seqId to the cell.
static void	CellUtil.setTimestamp(Cell cell, byte[] ts, int tsOffset)	Sets the given timestamp to the cell.
static void	CellUtil.setTimestamp(Cell cell, long ts)	Sets the given timestamp to the cell.
static void	PrivateCellUtil.setTimestamp(Cell cell, byte[] ts)	Sets the given timestamp to the cell.
static void	PrivateCellUtil.setTimestamp(Cell cell, long ts)	Sets the given timestamp to the cell.
static String	CellUtil.toString(Cell cell, boolean verbose)	Returns a string representation of the cell
static boolean	PrivateCellUtil.updateLatestStamp(Cell cell, byte[] ts)	Sets the given timestamp to the cell iff current timestamp is HConstants.LATEST_TIMESTAMP.
static void	PrivateCellUtil.writeFamily(OutputStream out, Cell cell, byte flength)	Writes the family from the given cell to the output stream
static void	PrivateCellUtil.writeQualifier(OutputStream out, Cell cell, int qlength)	Writes the qualifier from the given cell to the output stream
static void	PrivateCellUtil.writeQualifierSkippingBytes(DataOutputStream out, Cell cell, int qlength, int commonPrefix)	Writes the qualifier from the given cell to the output stream excluding the common prefix
static void	PrivateCellUtil.writeRow(OutputStream out, Cell cell, short rlength)	Writes the row from the given cell to the output stream
static void	PrivateCellUtil.writeRowKeyExcludingCommon(Cell cell, short rLen, int commonPrefix, DataOutputStream out)	Write rowkey excluding the common part.
static void	PrivateCellUtil.writeRowSkippingBytes(DataOutputStream out, Cell cell, short rlength, int commonPrefix)	Writes the row from the given cell to the output stream excluding the common prefix

Method parameters in org.apache.hadoop.hbase with type arguments of type Cell

Modifier and Type	Method	Description
static void	HBaseTestingUtility.assertKVListsEqual(String additionalMsg, List<? extends Cell> expected, List<? extends Cell> actual)	Deprecated.
static void	CellUtil.cloneIfNecessary(ArrayList<Cell> cells)
static boolean	KeyValueTestUtil.containsIgnoreMvccVersion(Collection<? extends Cell> kvCollection1, Collection<? extends Cell> kvCollection2)	Checks whether KeyValues from kvCollection2 are contained in kvCollection1.
static CellScanner	CellUtil.createCellScanner(Iterable<Cell> cellIterable)	Returns CellScanner interface over cellIterable
static CellScanner	CellUtil.createCellScanner(Iterator<Cell> cells)	Returns CellScanner interface over cellIterable or null if cells is null
static CellScanner	CellUtil.createCellScanner(NavigableMap<byte[],List<Cell>> map)	Flatten the map of cells out under the CellScanner
static String	CellUtil.getCellKeyAsString(Cell cell, Function<Cell,String> rowConverter)	Return the Key portion of the passed cell as a String.

Uses of Cell in org.apache.hadoop.hbase.backup.impl

Methods in org.apache.hadoop.hbase.backup.impl with parameters of type Cell

Modifier and Type	Method	Description
private String	BackupSystemTable.cellKeyToBackupSetName(Cell current)	Converts cell key to backup set name.
private BackupInfo	BackupSystemTable.cellToBackupInfo(Cell current)	Converts cell to backup info instance.
private String[]	BackupSystemTable.cellValueToBackupSet(Cell current)	Converts cell to backup set list.

Uses of Cell in org.apache.hadoop.hbase.backup.mapreduce

Methods in org.apache.hadoop.hbase.backup.mapreduce with parameters of type Cell

Modifier and Type	Method	Description
void	MapReduceHFileSplitterJob.HFileCellMapper.map(org.apache.hadoop.io.NullWritable key, Cell value, org.apache.hadoop.mapreduce.Mapper<org.apache.hadoop.io.NullWritable,Cell,org.apache.hadoop.io.WritableComparable<?>,Cell>.org.apache.hadoop.mapreduce.Mapper.Context context)

Uses of Cell in org.apache.hadoop.hbase.client

Fields in org.apache.hadoop.hbase.client with type parameters of type Cell

Modifier and Type	Field	Description
(package private) List<Cell>	ClientSideRegionScanner.values

Methods in org.apache.hadoop.hbase.client that return Cell

Modifier and Type	Method	Description
Cell	Result.getColumnLatestCell(byte[] family, byte[] qualifier)	The Cell for the most recent timestamp for a given column.
Cell	Result.getColumnLatestCell(byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength)	The Cell for the most recent timestamp for a given column.
Cell[]	Result.rawCells()	Return the array of Cells backing this Result instance.

Methods in org.apache.hadoop.hbase.client that return types with arguments of type Cell

Modifier and Type	Method	Description
List<Cell>	Mutation.get(byte[] family, byte[] qualifier)	Returns a list of all KeyValue objects with matching column family and qualifier.
List<Cell>	Result.getColumnCells(byte[] family, byte[] qualifier)	Return the Cells for the specific column.
NavigableMap<byte[],List<Cell>>	Mutation.getFamilyCellMap()	Method for retrieving the put's familyMap
List<Cell>	Result.listCells()	Create a sorted list of the Cell's in this result.

Methods in org.apache.hadoop.hbase.client with parameters of type Cell

Modifier and Type	Method	Description
Append	Append.add(Cell cell)	Deprecated. Since 3.0.0, and the method signature will be changed in 4.0.0, where we will throw IOException out when the row of the given cell does not match.
Delete	Delete.add(Cell cell)	Add an existing delete marker to this Delete object.
Increment	Increment.add(Cell cell)	Add the specified KeyValue to this operation.
(package private) Mutation	Mutation.add(Cell cell)
Put	Put.add(Cell cell)	Add the specified KeyValue to this Put operation.
private int	Result.binarySearch(Cell[] kvs, byte[] family, byte[] qualifier)
private int	Result.binarySearch(Cell[] kvs, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength)	Searches for the latest value for the specified column.
static Result	Result.create(Cell[] cells)	Instantiate a Result with the specified array of KeyValues.
static Result	Result.create(Cell[] cells, Boolean exists, boolean stale)
static Result	Result.create(Cell[] cells, Boolean exists, boolean stale, boolean mayHaveMoreCellsInRow)

Method parameters in org.apache.hadoop.hbase.client with type arguments of type Cell

Modifier and Type	Method	Description
static Result	Result.create(List<? extends Cell> cells)	Instantiate a Result with the specified List of KeyValues.
static Result	Result.create(List<? extends Cell> cells, Boolean exists)
static Result	Result.create(List<? extends Cell> cells, Boolean exists, boolean stale)
static Result	Result.create(List<? extends Cell> cells, Boolean exists, boolean stale, boolean mayHaveMoreCellsInRow)

Constructor parameters in org.apache.hadoop.hbase.client with type arguments of type Cell

Modifier	Constructor	Description
	Append(byte[] row, long ts, NavigableMap<byte[],List<Cell>> familyMap)	Construct the Append with user defined data.
	Delete(byte[] row, long ts, NavigableMap<byte[],List<Cell>> familyMap)	Construct the Delete with user defined data.
	Increment(byte[] row, long ts, NavigableMap<byte[],List<Cell>> familyMap)	Construct the Increment with user defined data.
protected	Mutation(byte[] row, long ts, NavigableMap<byte[],List<Cell>> familyMap)	Construct the mutation with user defined data.
	Put(byte[] row, long ts, NavigableMap<byte[],List<Cell>> familyMap)	Construct the Put with user defined data.

Uses of Cell in org.apache.hadoop.hbase.client.coprocessor

Methods in org.apache.hadoop.hbase.client.coprocessor with parameters of type Cell

Modifier and Type	Method	Description
BigDecimal	BigDecimalColumnInterpreter.getValue(byte[] colFamily, byte[] colQualifier, Cell kv)
Double	DoubleColumnInterpreter.getValue(byte[] colFamily, byte[] colQualifier, Cell c)
Long	LongColumnInterpreter.getValue(byte[] colFamily, byte[] colQualifier, Cell kv)

Uses of Cell in org.apache.hadoop.hbase.coprocessor

Methods in org.apache.hadoop.hbase.coprocessor that return Cell

Modifier and Type	Method	Description
default Cell	RegionObserver.postMutationBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)	Deprecated. since 2.2.0 and will be removedin 4.0.0.

Methods in org.apache.hadoop.hbase.coprocessor that return types with arguments of type Cell

Modifier and Type	Method	Description
default List<Pair<Cell,Cell>>	RegionObserver.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
default List<Pair<Cell,Cell>>	RegionObserver.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
default List<Pair<Cell,Cell>>	RegionObserver.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.
default List<Pair<Cell,Cell>>	RegionObserver.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.

Methods in org.apache.hadoop.hbase.coprocessor with parameters of type Cell

Modifier and Type	Method	Description
abstract T	ColumnInterpreter.getValue(byte[] colFamily, byte[] colQualifier, Cell c)	Returns value of type T
default Cell	RegionObserver.postMutationBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)	Deprecated. since 2.2.0 and will be removedin 4.0.0.
default boolean	RegionObserver.postScannerFilterRow(ObserverContext<? extends RegionCoprocessorEnvironment> c, InternalScanner s, Cell curRowCell, boolean hasMore)	This will be called by the scan flow when the current scanned row is being filtered out by the filter.
default void	RegionObserver.prePrepareTimeStampForDeleteVersion(ObserverContext<? extends RegionCoprocessorEnvironment> c, Mutation mutation, Cell cell, byte[] byteNow, Get get)	Deprecated. Since hbase-2.0.0.

Method parameters in org.apache.hadoop.hbase.coprocessor with type arguments of type Cell

Modifier and Type	Method	Description
default List<Pair<Cell,Cell>>	RegionObserver.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
default List<Pair<Cell,Cell>>	RegionObserver.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
default void	RegionObserver.postGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> c, Get get, List<Cell> result)	Called after the client performs a Get
default List<Pair<Cell,Cell>>	RegionObserver.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.
default List<Pair<Cell,Cell>>	RegionObserver.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)	Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.
void	MetaTableMetrics.ExampleRegionObserverMeta.preGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> e, Get get, List<Cell> results)
default void	RegionObserver.preGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> c, Get get, List<Cell> result)	Called before the client performs a Get

Uses of Cell in org.apache.hadoop.hbase.coprocessor.example

Methods in org.apache.hadoop.hbase.coprocessor.example that return Cell

Modifier and Type	Method	Description
private Cell	WriteHeavyIncrementObserver.createCell(byte[] row, byte[] family, byte[] qualifier, long ts, long value)

Method parameters in org.apache.hadoop.hbase.coprocessor.example with type arguments of type Cell

Modifier and Type	Method	Description
private Delete	BulkDeleteEndpoint.createDeleteMutation(List<Cell> deleteRow, org.apache.hadoop.hbase.shaded.coprocessor.example.generated.BulkDeleteProtos.BulkDeleteRequest.DeleteType deleteType, Long timestamp)
void	ExampleRegionObserverWithMetrics.ExampleRegionObserver.postGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> e, Get get, List<Cell> results)
void	ExampleRegionObserverWithMetrics.ExampleRegionObserver.preGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> e, Get get, List<Cell> results)
void	WriteHeavyIncrementObserver.preGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> c, Get get, List<Cell> result)

Uses of Cell in org.apache.hadoop.hbase.coprocessor.example.row.stats

Fields in org.apache.hadoop.hbase.coprocessor.example.row.stats declared as Cell

Modifier and Type	Field	Description
private Cell	RowStatisticsImpl.largestCell
private Cell	RowStatisticsImpl.largestCellRef
private Cell	RowStatisticsImpl.largestRowRef
private Cell	RowStatisticsCompactionObserver.RowStatisticsScanner.lastCell

Methods in org.apache.hadoop.hbase.coprocessor.example.row.stats that return Cell

Modifier and Type	Method	Description
Cell	RowStatisticsImpl.getLargestCell()

Methods in org.apache.hadoop.hbase.coprocessor.example.row.stats with parameters of type Cell

Modifier and Type	Method	Description
void	RowStatisticsImpl.consumeCell(Cell cell)
void	RowStatisticsImpl.handleRowChanged(Cell lastCell)
private boolean	RowStatisticsCompactionObserver.RowStatisticsScanner.rowChanged(Cell cell)

Uses of Cell in org.apache.hadoop.hbase.coprocessor.example.row.stats.utils

Methods in org.apache.hadoop.hbase.coprocessor.example.row.stats.utils that return Cell

Modifier and Type	Method	Description
static Cell	RowStatisticsUtil.cloneWithoutValue(RawCellBuilder cellBuilder, Cell cell)

Methods in org.apache.hadoop.hbase.coprocessor.example.row.stats.utils with parameters of type Cell

Modifier and Type	Method	Description
static Cell	RowStatisticsUtil.cloneWithoutValue(RawCellBuilder cellBuilder, Cell cell)

Uses of Cell in org.apache.hadoop.hbase.filter

Classes in org.apache.hadoop.hbase.filter that implement Cell

Modifier and Type	Class	Description
(package private) static class	KeyOnlyFilter.KeyOnlyByteBufferExtendedCell
(package private) static class	KeyOnlyFilter.KeyOnlyCell

Fields in org.apache.hadoop.hbase.filter declared as Cell

Modifier and Type	Field	Description
protected Cell	PrefixFilter.forwardNextCellHint
protected Cell	PrefixFilter.reversedNextCellHint

Fields in org.apache.hadoop.hbase.filter with type parameters of type Cell

Modifier and Type	Field	Description
private List<Cell>	FilterListWithOR.prevCellList

Methods in org.apache.hadoop.hbase.filter that return Cell

Modifier and Type	Method	Description
private Cell	KeyOnlyFilter.createKeyOnlyCell(ExtendedCell c)
Cell	ColumnPaginationFilter.getNextCellHint(Cell cell)
Cell	ColumnPrefixFilter.getNextCellHint(Cell cell)
Cell	ColumnRangeFilter.getNextCellHint(Cell cell)
abstract Cell	Filter.getNextCellHint(Cell currentCell)	If the filter returns the match code SEEK_NEXT_USING_HINT, then it should also tell which is the next key it must seek to.
Cell	FilterBase.getNextCellHint(Cell currentCell)	Filters that are not sure which key must be next seeked to, can inherit this implementation that, by default, returns a null Cell.
Cell	FilterList.getNextCellHint(Cell currentCell)
Cell	FilterListWithAND.getNextCellHint(Cell currentCell)
Cell	FilterListWithOR.getNextCellHint(Cell currentCell)
Cell	FilterWrapper.getNextCellHint(Cell currentCell)
Cell	FuzzyRowFilter.getNextCellHint(Cell currentCell)
Cell	MultipleColumnPrefixFilter.getNextCellHint(Cell cell)
Cell	MultiRowRangeFilter.getNextCellHint(Cell currentKV)
Cell	PrefixFilter.getNextCellHint(Cell cell)
Cell	TimestampsFilter.getNextCellHint(Cell currentCell)	Pick the next cell that the scanner should seek to.
abstract Cell	Filter.transformCell(Cell v)	Give the filter a chance to transform the passed Cell.
Cell	FilterBase.transformCell(Cell v)	By default no transformation takes place Give the filter a chance to transform the passed Cell.
Cell	FilterList.transformCell(Cell c)
Cell	FilterListBase.transformCell(Cell c)	For FilterList, we can consider a filter list as a node in a tree.
Cell	FilterWrapper.transformCell(Cell v)
Cell	KeyOnlyFilter.transformCell(Cell cell)
Cell	SkipFilter.transformCell(Cell v)
Cell	WhileMatchFilter.transformCell(Cell v)

Methods in org.apache.hadoop.hbase.filter with parameters of type Cell

Modifier and Type	Method	Description
private Filter.ReturnCode	FilterListWithOR.calculateReturnCodeByPrevCellAndRC(Filter subFilter, Cell currentCell, Cell prevCell, Filter.ReturnCode prevCode)	For MUST_PASS_ONE, we cannot make sure that when filter-A in filter list return NEXT_COL then the next cell passing to filterList will be the first cell in next column, because if filter-B in filter list return SKIP, then the filter list will return SKIP.
protected int	FilterListBase.compareCell(Cell a, Cell b)
protected boolean	CompareFilter.compareFamily(CompareOperator op, ByteArrayComparable comparator, Cell cell)
protected boolean	CompareFilter.compareQualifier(CompareOperator op, ByteArrayComparable comparator, Cell cell)
private static int	ColumnPrefixFilter.compareQualifierPart(Cell cell, int length, byte[] prefix)
protected boolean	CompareFilter.compareRow(CompareOperator op, ByteArrayComparable comparator, Cell cell)
private boolean	ColumnValueFilter.compareValue(CompareOperator op, ByteArrayComparable comparator, Cell cell)	This method is used to determine a cell should be included or filtered out.
protected boolean	CompareFilter.compareValue(CompareOperator op, ByteArrayComparable comparator, Cell cell)
Filter.ReturnCode	ColumnCountGetFilter.filterCell(Cell c)
Filter.ReturnCode	ColumnPaginationFilter.filterCell(Cell c)
Filter.ReturnCode	ColumnPrefixFilter.filterCell(Cell cell)
Filter.ReturnCode	ColumnRangeFilter.filterCell(Cell c)
Filter.ReturnCode	ColumnValueFilter.filterCell(Cell c)
Filter.ReturnCode	DependentColumnFilter.filterCell(Cell c)
Filter.ReturnCode	FamilyFilter.filterCell(Cell c)
Filter.ReturnCode	Filter.filterCell(Cell c)	A way to filter based on the column family, column qualifier and/or the column value.
Filter.ReturnCode	FilterAllFilter.filterCell(Cell c)
Filter.ReturnCode	FilterList.filterCell(Cell c)
Filter.ReturnCode	FilterListWithAND.filterCell(Cell c)
Filter.ReturnCode	FilterListWithOR.filterCell(Cell c)
Filter.ReturnCode	FilterWrapper.filterCell(Cell c)
Filter.ReturnCode	FirstKeyOnlyFilter.filterCell(Cell c)
Filter.ReturnCode	FuzzyRowFilter.filterCell(Cell c)
Filter.ReturnCode	InclusiveStopFilter.filterCell(Cell c)
Filter.ReturnCode	KeyOnlyFilter.filterCell(Cell ignored)
Filter.ReturnCode	MultipleColumnPrefixFilter.filterCell(Cell c)
Filter.ReturnCode	MultiRowRangeFilter.filterCell(Cell ignored)
Filter.ReturnCode	PageFilter.filterCell(Cell ignored)
Filter.ReturnCode	PrefixFilter.filterCell(Cell c)
Filter.ReturnCode	QualifierFilter.filterCell(Cell c)
Filter.ReturnCode	RandomRowFilter.filterCell(Cell c)
Filter.ReturnCode	RowFilter.filterCell(Cell v)
Filter.ReturnCode	SingleColumnValueFilter.filterCell(Cell c)
Filter.ReturnCode	SkipFilter.filterCell(Cell c)
Filter.ReturnCode	TimestampsFilter.filterCell(Cell c)
Filter.ReturnCode	ValueFilter.filterCell(Cell c)
Filter.ReturnCode	WhileMatchFilter.filterCell(Cell c)
Filter.ReturnCode	ColumnPrefixFilter.filterColumn(Cell cell)
Filter.ReturnCode	MultipleColumnPrefixFilter.filterColumn(Cell cell)
private boolean	SingleColumnValueFilter.filterColumnValue(Cell cell)
boolean	ColumnCountGetFilter.filterRowKey(Cell cell)
boolean	ColumnPaginationFilter.filterRowKey(Cell cell)
boolean	ColumnPrefixFilter.filterRowKey(Cell cell)
boolean	ColumnRangeFilter.filterRowKey(Cell cell)
boolean	ColumnValueFilter.filterRowKey(Cell cell)
boolean	CompareFilter.filterRowKey(Cell cell)
abstract boolean	Filter.filterRowKey(Cell firstRowCell)	Filters a row based on the row key.
boolean	FilterAllFilter.filterRowKey(Cell cell)
boolean	FilterBase.filterRowKey(Cell cell)
boolean	FilterList.filterRowKey(Cell firstRowCell)
boolean	FilterListWithAND.filterRowKey(Cell firstRowCell)
boolean	FilterListWithOR.filterRowKey(Cell firstRowCell)
boolean	FilterWrapper.filterRowKey(Cell cell)
boolean	FirstKeyOnlyFilter.filterRowKey(Cell cell)
boolean	InclusiveStopFilter.filterRowKey(Cell firstRowCell)
boolean	KeyOnlyFilter.filterRowKey(Cell cell)
boolean	MultipleColumnPrefixFilter.filterRowKey(Cell cell)
boolean	MultiRowRangeFilter.filterRowKey(Cell firstRowCell)
boolean	PageFilter.filterRowKey(Cell cell)
boolean	PrefixFilter.filterRowKey(Cell firstRowCell)
boolean	RandomRowFilter.filterRowKey(Cell firstRowCell)
boolean	RowFilter.filterRowKey(Cell firstRowCell)
boolean	SingleColumnValueFilter.filterRowKey(Cell cell)
boolean	SkipFilter.filterRowKey(Cell cell)
boolean	TimestampsFilter.filterRowKey(Cell cell)
boolean	WhileMatchFilter.filterRowKey(Cell cell)
Cell	ColumnPaginationFilter.getNextCellHint(Cell cell)
Cell	ColumnPrefixFilter.getNextCellHint(Cell cell)
Cell	ColumnRangeFilter.getNextCellHint(Cell cell)
abstract Cell	Filter.getNextCellHint(Cell currentCell)	If the filter returns the match code SEEK_NEXT_USING_HINT, then it should also tell which is the next key it must seek to.
Cell	FilterBase.getNextCellHint(Cell currentCell)	Filters that are not sure which key must be next seeked to, can inherit this implementation that, by default, returns a null Cell.
Cell	FilterList.getNextCellHint(Cell currentCell)
Cell	FilterListWithAND.getNextCellHint(Cell currentCell)
Cell	FilterListWithOR.getNextCellHint(Cell currentCell)
Cell	FilterWrapper.getNextCellHint(Cell currentCell)
Cell	FuzzyRowFilter.getNextCellHint(Cell currentCell)
Cell	MultipleColumnPrefixFilter.getNextCellHint(Cell cell)
Cell	MultiRowRangeFilter.getNextCellHint(Cell currentKV)
Cell	PrefixFilter.getNextCellHint(Cell cell)
Cell	TimestampsFilter.getNextCellHint(Cell currentCell)	Pick the next cell that the scanner should seek to.
(package private) boolean	FuzzyRowFilter.RowTracker.lessThan(Cell currentCell, byte[] nextRowKey)
abstract Cell	Filter.transformCell(Cell v)	Give the filter a chance to transform the passed Cell.
Cell	FilterBase.transformCell(Cell v)	By default no transformation takes place Give the filter a chance to transform the passed Cell.
Cell	FilterList.transformCell(Cell c)
Cell	FilterListBase.transformCell(Cell c)	For FilterList, we can consider a filter list as a node in a tree.
Cell	FilterWrapper.transformCell(Cell v)
Cell	KeyOnlyFilter.transformCell(Cell cell)
Cell	SkipFilter.transformCell(Cell v)
Cell	WhileMatchFilter.transformCell(Cell v)
private void	FilterListWithOR.updatePrevCellList(int index, Cell currentCell, Filter.ReturnCode currentRC)
(package private) boolean	FuzzyRowFilter.RowTracker.updateTracker(Cell currentCell)
(package private) void	FuzzyRowFilter.RowTracker.updateWith(Cell currentCell, Pair<byte[],byte[]> fuzzyData)

Method parameters in org.apache.hadoop.hbase.filter with type arguments of type Cell

Modifier and Type	Method	Description
void	DependentColumnFilter.filterRowCells(List<Cell> kvs)
abstract void	Filter.filterRowCells(List<Cell> kvs)	Chance to alter the list of Cells to be submitted.
void	FilterBase.filterRowCells(List<Cell> ignored)	Filters that never filter by modifying the returned List of Cells can inherit this implementation that does nothing.
void	FilterList.filterRowCells(List<Cell> cells)	Filters that never filter by modifying the returned List of Cells can inherit this implementation that does nothing.
void	FilterListBase.filterRowCells(List<Cell> cells)	Filters that never filter by modifying the returned List of Cells can inherit this implementation that does nothing.
void	FilterWrapper.filterRowCells(List<Cell> kvs)
void	SingleColumnValueExcludeFilter.filterRowCells(List<Cell> kvs)
FilterWrapper.FilterRowRetCode	FilterWrapper.filterRowCellsWithRet(List<Cell> kvs)

Uses of Cell in org.apache.hadoop.hbase.io.encoding

Classes in org.apache.hadoop.hbase.io.encoding that implement Cell

Modifier and Type	Class	Description
protected static class	BufferedDataBlockEncoder.OffheapDecodedExtendedCell
protected static class	BufferedDataBlockEncoder.OnheapDecodedCell	Copies only the key part of the keybuffer by doing a deep copy and passes the seeker state members for taking a clone.

Methods in org.apache.hadoop.hbase.io.encoding with parameters of type Cell

Modifier and Type	Method	Description
private int	RowIndexSeekerV1.binarySearch(Cell seekCell, boolean seekBefore)
static int	BufferedDataBlockEncoder.compareCommonFamilyPrefix(Cell left, Cell right, int familyCommonPrefix)
static int	BufferedDataBlockEncoder.compareCommonQualifierPrefix(Cell left, Cell right, int qualCommonPrefix)
static int	BufferedDataBlockEncoder.compareCommonRowPrefix(Cell left, Cell right, int rowCommonPrefix)	common prefixes
private static int	BufferedDataBlockEncoder.BufferedEncodedSeeker.findCommonPrefixInFamilyPart(Cell left, KeyValue.KeyOnlyKeyValue right, int familyCommonPrefix)
private static int	BufferedDataBlockEncoder.BufferedEncodedSeeker.findCommonPrefixInQualifierPart(Cell left, KeyValue.KeyOnlyKeyValue right, int qualifierCommonPrefix)
private static int	BufferedDataBlockEncoder.BufferedEncodedSeeker.findCommonPrefixInRowPart(Cell left, KeyValue.KeyOnlyKeyValue right, int rowCommonPrefix)

Uses of Cell in org.apache.hadoop.hbase.io.hfile

Fields in org.apache.hadoop.hbase.io.hfile declared as Cell

Modifier and Type	Field	Description
private Cell	HFileInfo.biggestCell	Biggest Cell in the file, key only.
private Cell	HFilePrettyPrinter.KeyValueStatsCollector.prevCell

Methods in org.apache.hadoop.hbase.io.hfile that return Cell

Modifier and Type	Method	Description
Cell	HFileWriterImpl.getLastCell()
Cell	CompoundBloomFilterWriter.getPrevCell()
abstract Cell	HFileBlockIndex.BlockIndexReader.midkey(HFile.CachingBlockReader cachingBlockReader)	An approximation to the HFile's mid-key.
Cell	HFileBlockIndex.ByteArrayKeyBlockIndexReader.midkey(HFile.CachingBlockReader cachingBlockReader)

Methods in org.apache.hadoop.hbase.io.hfile with parameters of type Cell

Modifier and Type	Method	Description
(package private) static int	HFileBlockIndex.BlockIndexReader.binarySearchNonRootIndex(Cell key, ByteBuff nonRootIndex, CellComparator comparator)	Performs a binary search over a non-root level index block.
protected int	HFileReaderImpl.HFileScannerImpl.blockSeek(Cell key, boolean seekBefore)	Within a loaded block, seek looking for the last key that is smaller than (or equal to?) the key we are interested in.
protected boolean	HFileWriterImpl.checkKey(Cell cell)	Checks that the given Cell's key does not violate the key order.
void	HFilePrettyPrinter.KeyValueStatsCollector.collect(Cell cell, boolean printStatRanges)
boolean	CompoundBloomFilter.contains(Cell keyCell, ByteBuff bloom, BloomType type)
private boolean	CompoundBloomFilter.containsInternal(Cell keyCell, ByteBuff bloom, BloomType type)
private String	HFileWriterImpl.getLexicalErrorMessage(Cell cell)
static int	HFileBlockIndex.BlockIndexReader.locateNonRootIndexEntry(ByteBuff nonRootBlock, Cell key, CellComparator comparator)	Search for one key using the secondary index in a non-root block.
abstract int	HFileBlockIndex.BlockIndexReader.rootBlockContainingKey(Cell key)	Finds the root-level index block containing the given key.
int	HFileBlockIndex.ByteArrayKeyBlockIndexReader.rootBlockContainingKey(Cell key)
int	HFileBlockIndex.CellBasedKeyBlockIndexReader.rootBlockContainingKey(Cell key)
int	HFileBlockIndex.CellBasedKeyBlockIndexReaderV2.rootBlockContainingKey(Cell key)
int	HFileIndexBlockEncoder.EncodedSeeker.rootBlockContainingKey(Cell key)
int	NoOpIndexBlockEncoder.NoOpEncodedSeeker.rootBlockContainingKey(Cell key)

Uses of Cell in org.apache.hadoop.hbase.mapreduce

Fields in org.apache.hadoop.hbase.mapreduce declared as Cell

Modifier and Type	Field	Description
private Cell	HFileInputFormat.HFileRecordReader.value	A private cache of the key value so it doesn't need to be loaded twice from the scanner.

Methods in org.apache.hadoop.hbase.mapreduce with type parameters of type Cell

Modifier and Type	Method	Description
(package private) static <V extends Cell> org.apache.hadoop.mapreduce.RecordWriter<ImmutableBytesWritable,V>	HFileOutputFormat2.createRecordWriter(org.apache.hadoop.mapreduce.TaskAttemptContext context, org.apache.hadoop.mapreduce.OutputCommitter committer)

Methods in org.apache.hadoop.hbase.mapreduce that return Cell

Modifier and Type	Method	Description
private Cell	SyncTable.SyncMapper.checkAndResetTimestamp(Cell sourceCell)
Cell	CellCreator.create(byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength, long timestamp, byte[] value, int voffset, int vlength)
Cell	CellCreator.create(byte[] row, int roffset, int rlength, byte[] family, int foffset, int flength, byte[] qualifier, int qoffset, int qlength, long timestamp, byte[] value, int voffset, int vlength, List<Tag> tags)
Cell	HFileInputFormat.HFileRecordReader.getCurrentValue()
Cell	SyncTable.SyncMapper.CellScanner.nextCellInRow()	Returns the next Cell in the current row or null iff none remain.

Methods in org.apache.hadoop.hbase.mapreduce that return types with arguments of type Cell

Modifier and Type	Method	Description
org.apache.hadoop.mapreduce.RecordReader<org.apache.hadoop.io.NullWritable,Cell>	HFileInputFormat.createRecordReader(org.apache.hadoop.mapreduce.InputSplit split, org.apache.hadoop.mapreduce.TaskAttemptContext context)
org.apache.hadoop.mapreduce.RecordWriter<ImmutableBytesWritable,Cell>	HFileOutputFormat2.getRecordWriter(org.apache.hadoop.mapreduce.TaskAttemptContext context)

Methods in org.apache.hadoop.hbase.mapreduce with parameters of type Cell

Modifier and Type	Method	Description
protected void	Import.Importer.addPutToKv(Put put, Cell kv)
private Cell	SyncTable.SyncMapper.checkAndResetTimestamp(Cell sourceCell)
private int	SyncTable.SyncMapper.compareCellKeysWithinRow(Cell c1, Cell c2)	Compare families, qualifiers, and timestamps of the given Cells.
KeyValue	CellSerialization.CellDeserializer.deserialize(Cell ignore)
protected boolean	WALPlayer.WALMapper.filter(org.apache.hadoop.mapreduce.Mapper<WALKey,WALEdit,ImmutableBytesWritable,Mutation>.org.apache.hadoop.mapreduce.Mapper.Context context, Cell cell)
int	Import.CellWritableComparablePartitioner.getPartition(Import.CellWritableComparable key, Cell value, int numPartitions)
void	CellSerialization.CellSerializer.serialize(Cell kv)

Method parameters in org.apache.hadoop.hbase.mapreduce with type arguments of type Cell

Modifier and Type	Method	Description
CellSerialization.CellDeserializer	CellSerialization.getDeserializer(Class<Cell> t)
CellSerialization.CellSerializer	CellSerialization.getSerializer(Class<Cell> c)
protected void	CellSortReducer.reduce(ImmutableBytesWritable row, Iterable<Cell> kvs, org.apache.hadoop.mapreduce.Reducer<ImmutableBytesWritable,Cell,ImmutableBytesWritable,Cell>.org.apache.hadoop.mapreduce.Reducer.Context context)
protected void	Import.CellReducer.reduce(Import.CellWritableComparable row, Iterable<Cell> kvs, org.apache.hadoop.mapreduce.Reducer<Import.CellWritableComparable,Cell,ImmutableBytesWritable,Cell>.org.apache.hadoop.mapreduce.Reducer.Context context)
protected void	PreSortedCellsReducer.reduce(KeyOnlyCellComparable keyComparable, Iterable<Cell> values, org.apache.hadoop.mapreduce.Reducer<KeyOnlyCellComparable,Cell,ImmutableBytesWritable,Cell>.org.apache.hadoop.mapreduce.Reducer.Context context)

Constructors in org.apache.hadoop.hbase.mapreduce with parameters of type Cell

Modifier	Constructor	Description
	CellWritableComparable(Cell kv)

Uses of Cell in org.apache.hadoop.hbase.master.region

Fields in org.apache.hadoop.hbase.master.region with type parameters of type Cell

Modifier and Type	Field	Description
private final List<Cell>	RegionScannerAsResultScanner.cells

Uses of Cell in org.apache.hadoop.hbase.mob

Methods in org.apache.hadoop.hbase.mob with parameters of type Cell

Modifier and Type	Method	Description
static String	MobUtils.getMobFileName(Cell cell)	Gets the mob file name from the mob ref cell.
static int	MobUtils.getMobValueLength(Cell cell)	Gets the mob value length from the mob ref cell.
static boolean	MobUtils.hasValidMobRefCellValue(Cell cell)	Indicates whether the current mob ref cell has a valid value.

Uses of Cell in org.apache.hadoop.hbase.procedure2.store.region

Methods in org.apache.hadoop.hbase.procedure2.store.region with parameters of type Cell

Modifier and Type	Method	Description
private void	HFileProcedurePrettyPrinter.printCell(Cell cell)

Uses of Cell in org.apache.hadoop.hbase.quotas

Methods in org.apache.hadoop.hbase.quotas with parameters of type Cell

Modifier and Type	Method	Description
protected static String	QuotaTableUtil.extractSnapshotNameFromSizeCell(Cell c)
(package private) static long	QuotaTableUtil.parseSnapshotSize(Cell c)	Parses the snapshot size from the given Cell's value.

Method parameters in org.apache.hadoop.hbase.quotas with type arguments of type Cell

Modifier and Type	Method	Description
void	DefaultOperationQuota.addScanResultCells(List<Cell> cells)
void	NoopOperationQuota.addScanResultCells(List<Cell> cells)
void	OperationQuota.addScanResultCells(List<Cell> cells)	Add a scan result in the form of cells.
static long	QuotaUtil.calculateCellsSize(List<Cell> cells)

Uses of Cell in org.apache.hadoop.hbase.regionserver

Classes in org.apache.hadoop.hbase.regionserver with type parameters of type Cell

Modifier and Type	Class	Description
class	CellArrayMap<T extends Cell>	CellArrayMap is a simple array of Cells and cannot be allocated off-heap.
class	CellChunkMap<T extends Cell>	CellChunkMap is an array of serialized representations of Cell (pointing to Chunks with full Cell data) and can be allocated both off-heap and on-heap.
class	CellFlatMap<T extends Cell>	CellFlatMap stores a constant number of elements and is immutable after creation stage.
class	CellSet<T extends Cell>	A Set of Cells, where an add will overwrite the entry if already exists in the set.

Classes in org.apache.hadoop.hbase.regionserver that implement Cell

Modifier and Type	Class	Description
class	ByteBufferChunkKeyValue	ByteBuffer based cell which has the chunkid at the 0th offset
class	NoTagByteBufferChunkKeyValue	ByteBuffer based cell which has the chunkid at the 0th offset and with no tags

Fields in org.apache.hadoop.hbase.regionserver declared as Cell

Modifier and Type	Field	Description
private final T[]	CellArrayMap.block
private Cell	StripeMultiFileWriter.BoundaryMultiWriter.lastCell
private Cell	StripeMultiFileWriter.SizeMultiWriter.lastCell
private Cell	ScannerContext.lastPeekedCell

Fields in org.apache.hadoop.hbase.regionserver with type parameters of type Cell

Modifier and Type	Field	Description
private static final List<Cell>	RegionScannerImpl.MOCKED_LIST	A mocked list implementation - discards all updates.

Methods in org.apache.hadoop.hbase.regionserver that return Cell

Modifier and Type	Method	Description
Cell	CellSet.get(Cell kv)
(package private) Cell	ScannerContext.getLastPeekedCell()

Methods in org.apache.hadoop.hbase.regionserver that return types with arguments of type Cell

Modifier and Type	Method	Description
List<Cell>	HRegion.get(Get get, boolean withCoprocessor)
private List<Cell>	HRegion.get(Get get, boolean withCoprocessor, long nonceGroup, long nonce)
List<Cell>	Region.get(Get get, boolean withCoprocessor)	Do a get based on the get parameter.
private List<Cell>	HRegion.getInternal(Get get, boolean withCoprocessor, long nonceGroup, long nonce)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postAppendBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postAppendBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postIncrementBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postIncrementBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)

Methods in org.apache.hadoop.hbase.regionserver with parameters of type Cell

Modifier and Type	Method	Description
protected boolean	CompactingMemStore.checkAndAddToActiveSize(MutableSegment currActive, Cell cellToAdd, MemStoreSizing memstoreSizing)	Check whether anything need to be done based on the current active set size.
private boolean	StoreFileReader.checkGeneralBloomFilter(byte[] key, Cell kvKey, BloomFilter bloomFilter)
protected void	ReversedStoreScanner.checkScanOrder(Cell prevKV, Cell kv, CellComparator comparator)
protected void	StoreScanner.checkScanOrder(Cell prevKV, Cell kv, CellComparator comparator)	Check whether scan as expected order
int	CompositeImmutableSegment.compare(Cell left, Cell right)
int	KeyValueHeap.KVScannerComparator.compare(Cell left, Cell right)	Compares two KeyValue
int	Segment.compare(Cell left, Cell right)
int	CompositeImmutableSegment.compareRows(Cell left, Cell right)
int	ReversedKeyValueHeap.ReversedKVScannerComparator.compareRows(Cell left, Cell right)	Compares rows of two KeyValue
int	Segment.compareRows(Cell left, Cell right)
Filter.ReturnCode	MobReferenceOnlyFilter.filterCell(Cell cell)
private boolean	RegionScannerImpl.filterRowKey(Cell current)
Cell	CellSet.get(Cell kv)
(package private) static int	Segment.getCellLength(Cell cell)	Get cell length after serialized in KeyValue
private static long	HRegion.MutationBatchOperation.getLongValue(Cell cell)	Returns Get the long out of the passed in Cell
private HStore	HRegion.getStore(Cell cell)	Return HStore instance.
protected long	Segment.heapSizeChange(Cell cell, boolean allocated)
private boolean	StripeMultiFileWriter.BoundaryMultiWriter.isCellAfterCurrentWriter(Cell cell)
private static final boolean	StripeStoreFileManager.isOpen(Cell key)
private boolean	StoreFileScanner.isStillAtSeekTargetAfterSkippingNewerKvs(Cell seekKey)
private boolean	RegionScannerImpl.moreCellsInRow(Cell nextKv, Cell currentRowCell)	Based on the nextKv in the heap, and the current row, decide whether or not there are more cells to be read in the heap.
protected boolean	RegionScannerImpl.nextRow(ScannerContext scannerContext, Cell curRowCell)
protected boolean	ReversedRegionScannerImpl.nextRow(ScannerContext scannerContext, Cell curRowCell)
private final int	StripeStoreFileManager.nonOpenRowCompare(Cell k1, byte[] k2)
protected long	Segment.offHeapSizeChange(Cell cell, boolean allocated)
boolean	RegionCoprocessorHost.postScannerFilterRow(InternalScanner s, Cell curRowCell)	This will be called by the scan flow when the current scanned row is being filtered out by the filter.
private void	StripeMultiFileWriter.BoundaryMultiWriter.prepareWriterFor(Cell cell)
boolean	RegionCoprocessorHost.prePrepareTimeStampForDeleteVersion(Mutation mutation, Cell kv, byte[] byteNow, Get get)	Supports Coprocessor 'bypass'.
private void	HRegion.replayWALMetaEdit(Cell cell)	Replay the meta edits, i.e, flush marker, compaction marker, bulk load marker, region event marker, etc.
protected void	StripeMultiFileWriter.sanityCheckLeft(byte[] left, Cell cell)	Subclasses can call this method to make sure the first KV is within multi-writer range.
protected void	StripeMultiFileWriter.sanityCheckRight(byte[] right, Cell cell)	Subclasses can call this method to make sure the last KV is within multi-writer range.
(package private) void	ScannerContext.setLastPeekedCell(Cell lastPeekedCell)
protected boolean	RegionScannerImpl.shouldStop(Cell currentRowCell)
protected boolean	ReversedRegionScannerImpl.shouldStop(Cell currentRowCell)
NavigableSet<T>	CellSet.subSet(Cell fromElement, boolean fromInclusive, Cell toElement, boolean toInclusive)
Iterator<HStoreFile>	DefaultStoreFileManager.updateCandidateFilesForRowKeyBefore(Iterator<HStoreFile> candidateFiles, KeyValue targetKey, Cell candidate)
Iterator<HStoreFile>	StoreFileManager.updateCandidateFilesForRowKeyBefore(Iterator<HStoreFile> candidateFiles, KeyValue targetKey, Cell candidate)	Updates the candidate list for finding row key before.
Iterator<HStoreFile>	StripeStoreFileManager.updateCandidateFilesForRowKeyBefore(Iterator<HStoreFile> candidateFiles, KeyValue targetKey, Cell candidate)	See StoreFileManager.getCandidateFilesForRowKeyBefore(KeyValue) and StoreFileManager.updateCandidateFilesForRowKeyBefore(Iterator, KeyValue, Cell) for details on this methods.
private void	HRegion.updateDeleteLatestVersionTimestamp(Cell cell, Get get, int count, byte[] byteNow)

Method parameters in org.apache.hadoop.hbase.regionserver with type arguments of type Cell

Modifier and Type	Method	Description
void	HRegion.checkTimestamps(Map<byte[],List<Cell>> familyMap, long now)	Check the collection of families for valid timestamps
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postAppendBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postAppendBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
void	RegionCoprocessorHost.postGet(Get get, List<Cell> results)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postIncrementBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postIncrementBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
boolean	RegionCoprocessorHost.preGet(Get get, List<Cell> results)	Supports Coprocessor 'bypass'.
private void	HRegion.recordMutationWithoutWal(Map<byte[],List<Cell>> familyMap)	Update LongAdders for number of puts without wal and the size of possible data loss.

Constructors in org.apache.hadoop.hbase.regionserver with parameters of type Cell

Modifier	Constructor	Description
	CellArrayMap(Comparator<? super T> comparator, T[] b, int min, int max, boolean descending)

Uses of Cell in org.apache.hadoop.hbase.regionserver.regionreplication

Methods in org.apache.hadoop.hbase.regionserver.regionreplication with parameters of type Cell

Modifier and Type	Method	Description
(package private) Optional<org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor>	RegionReplicationSink.getStartFlushAllDescriptor(Cell metaCell)

Uses of Cell in org.apache.hadoop.hbase.regionserver.throttle

Method parameters in org.apache.hadoop.hbase.regionserver.throttle with type arguments of type Cell

Modifier and Type	Method	Description
void	StoreHotnessProtector.finish(Map<byte[],List<Cell>> familyMaps)
void	StoreHotnessProtector.start(Map<byte[],List<Cell>> familyMaps)

Uses of Cell in org.apache.hadoop.hbase.regionserver.wal

Methods in org.apache.hadoop.hbase.regionserver.wal with parameters of type Cell

Modifier and Type	Method	Description
private void	WALCellCodec.CompressedKvEncoder.writeCompressedValue(OutputStream out, Cell cell)

Method parameters in org.apache.hadoop.hbase.regionserver.wal with type arguments of type Cell

Modifier and Type	Method	Description
static void	WALUtil.filterCells(WALEdit edit, Function<Cell,Cell> mapper)
static void	WALUtil.filterCells(WALEdit edit, Function<Cell,Cell> mapper)

Uses of Cell in org.apache.hadoop.hbase.replication

Methods in org.apache.hadoop.hbase.replication that return Cell

Modifier and Type	Method	Description
private Cell	ChainWALEntryFilter.filterCell(WAL.Entry entry, Cell cell)
Cell	NamespaceTableCfWALEntryFilter.filterCell(WAL.Entry entry, Cell cell)
Cell	ScopeWALEntryFilter.filterCell(WAL.Entry entry, Cell cell)
Cell	WALCellFilter.filterCell(WAL.Entry entry, Cell cell)	Applies the filter, possibly returning a different Cell instance.

Methods in org.apache.hadoop.hbase.replication with parameters of type Cell

Modifier and Type	Method	Description
private void	VerifyWALEntriesReplicationEndpoint.checkCell(Cell cell)
private Cell	ChainWALEntryFilter.filterCell(WAL.Entry entry, Cell cell)
Cell	NamespaceTableCfWALEntryFilter.filterCell(WAL.Entry entry, Cell cell)
Cell	ScopeWALEntryFilter.filterCell(WAL.Entry entry, Cell cell)
Cell	WALCellFilter.filterCell(WAL.Entry entry, Cell cell)	Applies the filter, possibly returning a different Cell instance.
private static long	ReplicationBarrierFamilyFormat.getReplicationBarrier(Cell c)

Uses of Cell in org.apache.hadoop.hbase.replication.regionserver

Fields in org.apache.hadoop.hbase.replication.regionserver declared as Cell

Modifier and Type	Field	Description
private Cell	SerialReplicationSourceWALReader.firstCellInEntryBeforeFiltering

Methods in org.apache.hadoop.hbase.replication.regionserver with parameters of type Cell

Modifier and Type	Method	Description
boolean	SerialReplicationChecker.canPush(WAL.Entry entry, Cell firstCellInEdit)
private Put	ReplicationSink.processReplicationMarkerEntry(Cell cell)
void	SerialReplicationChecker.waitUntilCanPush(WAL.Entry entry, Cell firstCellInEdit)

Uses of Cell in org.apache.hadoop.hbase.rest

Fields in org.apache.hadoop.hbase.rest declared as Cell

Modifier and Type	Field	Description
private Cell	RowResultGenerator.cache
private Cell	ScannerResultGenerator.cache

Fields in org.apache.hadoop.hbase.rest with type parameters of type Cell

Modifier and Type	Field	Description
private Iterator<Cell>	ScannerResultGenerator.rowI
private Iterator<Cell>	RowResultGenerator.valuesI

Methods in org.apache.hadoop.hbase.rest that return Cell

Modifier and Type	Method	Description
Cell	RowResultGenerator.next()
Cell	ScannerResultGenerator.next()

Methods in org.apache.hadoop.hbase.rest with parameters of type Cell

Modifier and Type	Method	Description
abstract void	ResultGenerator.putBack(Cell kv)
void	RowResultGenerator.putBack(Cell kv)
void	ScannerResultGenerator.putBack(Cell kv)

Uses of Cell in org.apache.hadoop.hbase.rest.model

Constructors in org.apache.hadoop.hbase.rest.model with parameters of type Cell

Modifier	Constructor	Description
	CellModel(Cell cell)	Constructor from KeyValue This avoids copying the value from the cell, and tries to optimize generating the column value.

Uses of Cell in org.apache.hadoop.hbase.security.access

Methods in org.apache.hadoop.hbase.security.access that return Cell

Modifier and Type	Method	Description
private Cell	AccessController.createNewCellWithTags(Mutation mutation, Cell oldCell, Cell newCell)

Methods in org.apache.hadoop.hbase.security.access that return types with arguments of type Cell

Modifier and Type	Method	Description
List<Pair<Cell,Cell>>	AccessController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)

Methods in org.apache.hadoop.hbase.security.access with parameters of type Cell

Modifier and Type	Method	Description
boolean	AuthManager.authorizeCell(User user, TableName table, Cell cell, Permission.Action action)	Check if user has given action privilige in cell scope.
private Cell	AccessController.createNewCellWithTags(Mutation mutation, Cell oldCell, Cell newCell)
Filter.ReturnCode	AccessControlFilter.filterCell(Cell cell)
boolean	AccessControlFilter.filterRowKey(Cell cell)
private static Pair<String,Permission>	PermissionStorage.parsePermissionRecord(byte[] entryName, Cell kv, byte[] cf, byte[] cq, boolean filterPerms, String filterUser)

Method parameters in org.apache.hadoop.hbase.security.access with type arguments of type Cell

Modifier and Type	Method	Description
private static void	AccessController.addCellPermissions(byte[] perms, Map<byte[],List<Cell>> familyMap)
List<Pair<Cell,Cell>>	AccessController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
void	AccessController.preGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> c, Get get, List<Cell> result)
private void	AccessController.updateACL(RegionCoprocessorEnvironment e, Map<byte[],List<Cell>> familyMap)	Writes all table ACLs for the tables in the given Map up into ZooKeeper znodes.

Uses of Cell in org.apache.hadoop.hbase.security.visibility

Methods in org.apache.hadoop.hbase.security.visibility that return Cell

Modifier and Type	Method	Description
private Cell	VisibilityController.createNewCellWithTags(Mutation mutation, ExtendedCell newCell)

Methods in org.apache.hadoop.hbase.security.visibility that return types with arguments of type Cell

Modifier and Type	Method	Description
protected List<List<Cell>>	DefaultVisibilityLabelServiceImpl.getExistingLabelsWithAuths()
List<Pair<Cell,Cell>>	VisibilityController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)

Methods in org.apache.hadoop.hbase.security.visibility with parameters of type Cell

Modifier and Type	Method	Description
boolean	VisibilityExpEvaluator.evaluate(Cell cell)	Evaluates whether the passed cell passes Scan/Get Authorization.
Filter.ReturnCode	VisibilityController.DeleteVersionVisibilityExpressionFilter.filterCell(Cell cell)
Filter.ReturnCode	VisibilityLabelFilter.filterCell(Cell cell)
boolean	VisibilityController.DeleteVersionVisibilityExpressionFilter.filterRowKey(Cell cell)
boolean	VisibilityLabelFilter.filterRowKey(Cell cell)
void	VisibilityController.prePrepareTimeStampForDeleteVersion(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation delete, Cell cell, byte[] byteNow, Get get)

Method parameters in org.apache.hadoop.hbase.security.visibility with type arguments of type Cell

Modifier and Type	Method	Description
protected Pair<Map<String,Integer>,Map<String,List<Integer>>>	DefaultVisibilityLabelServiceImpl.extractLabelsAndAuths(List<List<Cell>> labelDetails)
List<Pair<Cell,Cell>>	VisibilityController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postAppendBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postIncrementBeforeWAL(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
void	VisibilityController.preGetOp(ObserverContext<? extends RegionCoprocessorEnvironment> e, Get get, List<Cell> results)

Uses of Cell in org.apache.hadoop.hbase.thrift

Methods in org.apache.hadoop.hbase.thrift with parameters of type Cell

Modifier and Type	Method	Description
static List<org.apache.hadoop.hbase.thrift.generated.TCell>	ThriftUtilities.cellFromHBase(Cell in)	This utility method creates a list of Thrift TCell "struct" based on an Hbase Cell object.
static List<org.apache.hadoop.hbase.thrift.generated.TCell>	ThriftUtilities.cellFromHBase(Cell[] in)	This utility method creates a list of Thrift TCell "struct" based on an Hbase Cell array.

Uses of Cell in org.apache.hadoop.hbase.thrift2

Methods in org.apache.hadoop.hbase.thrift2 that return Cell

Modifier and Type	Method	Description
static Cell	ThriftUtilities.toCell(ExtendedCellBuilder cellBuilder, byte[] row, org.apache.hadoop.hbase.thrift2.generated.TColumnValue columnValue)

Uses of Cell in org.apache.hadoop.hbase.tool

Methods in org.apache.hadoop.hbase.tool with parameters of type Cell

Modifier and Type	Method	Description
private static StoreFileWriter	BulkLoadHFilesTool.initStoreFileWriter(org.apache.hadoop.conf.Configuration conf, Cell cell, HFileContext hFileContext, CacheConfig cacheConf, BloomType bloomFilterType, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path outFile, AsyncTableRegionLocator loc)

Uses of Cell in org.apache.hadoop.hbase.util

Classes in org.apache.hadoop.hbase.util that implement Cell

Modifier and Type	Class	Description
class	MapReduceExtendedCell	A wrapper for a cell to be used with mapreduce, as the output value class for mappers/reducers.

Methods in org.apache.hadoop.hbase.util that return Cell

Modifier and Type	Method	Description
Cell	BloomContext.getLastCell()
Cell	BloomFilterWriter.getPrevCell()	Returns the previous cell written by this writer

Methods in org.apache.hadoop.hbase.util with parameters of type Cell

Modifier and Type	Method	Description
void	BloomFilterChunk.add(Cell cell)
static int	Bytes.binarySearch(Cell[] arr, Cell key, CellComparator comparator)	Binary search for keys in indexes.
boolean	BloomFilter.contains(Cell keyCell, ByteBuff bloom, BloomType type)	Check if the specified key is contained in the bloom filter.
static boolean	BloomFilterUtil.contains(Cell cell, ByteBuff bloomBuf, int bloomOffset, int bloomSize, Hash hash, int hashCount, BloomType type)

Constructors in org.apache.hadoop.hbase.util with parameters of type Cell

Modifier	Constructor	Description
	CellHashKey(Cell cell)
	RowBloomHashKey(Cell cell)
	RowColBloomHashKey(Cell cell)

Uses of Cell in org.apache.hadoop.hbase.wal

Methods in org.apache.hadoop.hbase.wal that return types with arguments of type Cell

Modifier and Type	Method	Description
ArrayList<Cell>	WALEdit.getCells()

Methods in org.apache.hadoop.hbase.wal with parameters of type Cell

Modifier and Type	Method	Description
WALEdit	WALEdit.add(Cell cell)
WALEdit	WALEdit.add(Cell cell, byte[] family)
static org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.BulkLoadDescriptor	WALEdit.getBulkLoadDescriptor(Cell cell)	Deserialized and returns a BulkLoadDescriptor from the passed in Cell
static org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.CompactionDescriptor	WALEdit.getCompaction(Cell kv)	Deserialized and returns a CompactionDescriptor is the KeyValue contains one.
static org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.FlushDescriptor	WALEdit.getFlushDescriptor(Cell cell)
static org.apache.hadoop.hbase.shaded.protobuf.generated.WALProtos.RegionEventDescriptor	WALEdit.getRegionEventDescriptor(Cell cell)
static boolean	WALEdit.isCompactionMarker(Cell cell)	Returns true if the given cell is a serialized WALProtos.CompactionDescriptor
static boolean	WALEdit.isMetaEditFamily(Cell cell)	Replaying WALs can read Cell-at-a-time so need this method in those cases.

Method parameters in org.apache.hadoop.hbase.wal with type arguments of type Cell

Modifier and Type	Method	Description
void	WALEdit.add(Map<byte[],List<Cell>> familyMap)	This is just for keeping compatibility for CPs, in HBase you should call the below WALEdit.addMap(Map) directly to avoid casting.
(package private) void	WALEdit.setCells(ArrayList<Cell> cells)	This is just for keeping compatibility for CPs, in HBase you should call the below WALEdit.setExtendedCells(ArrayList) directly to avoid casting.