PrivateCellUtil (Apache HBase 2.5.0 API)

java.lang.Object
- org.apache.hadoop.hbase.PrivateCellUtil

```
@InterfaceAudience.Private
public final class PrivateCellUtil
extends Object
```
Utility methods helpful slinging Cell instances. It has more powerful and rich set of APIs than those in CellUtil for internal usage.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`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`

Constructor Summary

Constructors
Modifier Constructor and Description

private PrivateCellUtil()
Private constructor to keep this class from being instantiated.

Constructors
Modifier	Constructor and Description
`private`	`PrivateCellUtil()` Private constructor to keep this class from being instantiated.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static byte[]`	`cloneTags(Cell cell)`
`static int`	`compare(CellComparator comparator, Cell left, byte[] key, int offset, int length)` Used when a cell needs to be compared with a key byte[] such as cases of finding the index from the index block, bloom keys from the bloom blocks This byte[] is expected to be serialized in the KeyValue serialization format If the KeyValue (Cell's) serialization format changes this method cannot be used.
`static int`	`compareFamily(Cell cell, ByteArrayComparable comparator)` Compare cell's column family against given comparator
`static int`	`compareKeyBasedOnColHint(CellComparator comparator, Cell nextIndexedCell, Cell currentCell, int foff, int flen, byte[] colHint, int coff, int clen, long ts, byte type)` Used to compare two cells based on the column hint provided.
`static int`	`compareKeyIgnoresMvcc(CellComparator comparator, Cell left, Cell right)` Compares only the key portion of a cell.
`static int`	`compareQualifier(Cell cell, ByteArrayComparable comparator)` Compare cell's qualifier against given comparator
`static int`	`compareRow(Cell cell, ByteArrayComparable comparator)` Compare cell's row against given comparator
`static int`	`compareValue(Cell cell, ByteArrayComparable comparator)` Compare cell's value against given comparator
`(package private) static int`	`compareWithoutRow(CellComparator comparator, Cell left, byte[] right, int roffset, int rlength, short rowlength)` Compare columnFamily, qualifier, timestamp, and key type (everything except the row).
`static void`	`compressFamily(OutputStream out, Cell cell, Dictionary dict)`
`static void`	`compressQualifier(OutputStream out, Cell cell, Dictionary dict)`
`static void`	`compressRow(OutputStream out, Cell cell, Dictionary dict)`
`static void`	`compressTags(OutputStream out, Cell cell, TagCompressionContext tagCompressionContext)` Compresses the tags to the given outputstream using the TagcompressionContext
`static int`	`copyTagsTo(Cell cell, byte[] destination, int destinationOffset)` Copies the tags info into the tag portion of the cell
`static int`	`copyTagsTo(Cell cell, ByteBuffer destination, int destinationOffset)` Copies the tags info into the tag portion of the cell
`static Cell`	`createCell(Cell cell, byte[] tags)` Returns A new cell which is having the extra tags also added to it.
`static Cell`	`createCell(Cell cell, byte[] value, byte[] tags)`
`static Cell`	`createCell(Cell cell, List<Tag> tags)` Returns A new cell which is having the extra tags also added to it.
`static Cell`	`createFirstDeleteFamilyCellOnRow(byte[] row, byte[] fam)` Create a Delete Family Cell for the specified row and family that would be smaller than all other possible Delete Family KeyValues that have the same row and family.
`static Cell`	`createFirstOnNextRow(Cell cell)`
`static Cell`	`createFirstOnRow(byte[] row)`
`static Cell`	`createFirstOnRow(byte[] row, byte[] family, byte[] col)`
`static Cell`	`createFirstOnRow(byte[] row, int roffset, short rlength)`
`static Cell`	`createFirstOnRow(byte[] row, int roffset, short rlength, byte[] family, int foffset, byte flength, byte[] col, int coffset, int clength)`
`static Cell`	`createFirstOnRow(Cell cell)` Create a Cell that is smaller than all other possible Cells for the given Cell's row.
`static Cell`	`createFirstOnRowCol(Cell cell)`
`static Cell`	`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 Cell`	`createFirstOnRowColTS(Cell cell, long ts)` Creates the first cell with the row/family/qualifier of this cell and the given timestamp.
`static Cell`	`createFirstOnRowFamily(Cell cell, byte[] fArray, int foff, int flen)`
`static Cell`	`createLastOnRow(byte[] row)`
`static Cell`	`createLastOnRow(Cell cell)` Create a Cell that is larger than all other possible Cells for the given Cell's row.
`static Cell`	`createLastOnRowCol(Cell cell)` Create a Cell that is larger than all other possible Cells for the given Cell's rk:cf:q.
`static Cell`	`createNextOnRowCol(Cell cell)` Return a new cell is located following input cell.
`(package private) static Cell`	`createNextOnRowCol(Cell cell, long ts, byte type)`
`static Cell`	`deepClone(Cell cell)` Deep clones the given cell if the cell supports deep cloning
`static boolean`	`equalsIgnoreMvccVersion(Cell a, Cell b)` special case for Cell.equals
`static int`	`estimatedSerializedSizeOf(Cell cell)` Estimate based on keyvalue's serialization format in the RPC layer.
`static int`	`estimatedSerializedSizeOfKey(Cell cell)` Calculates the serialized key size.
`static ByteRange`	`fillFamilyRange(Cell cell, ByteRange range)`
`static ByteRange`	`fillQualifierRange(Cell cell, ByteRange range)`
`static ByteRange`	`fillRowRange(Cell cell, ByteRange range)` ByteRange
`static ByteRange`	`fillTagRange(Cell cell, ByteRange range)`
`static ByteRange`	`fillValueRange(Cell cell, ByteRange range)`
`static int`	`findCommonPrefixInFlatKey(Cell c1, Cell c2, boolean bypassFamilyCheck, boolean withTsType)` Find length of common prefix in keys of the cells, considering key as byte[] if serialized in `KeyValue`.
`static byte[]`	`getCellKeySerializedAsKeyValueKey(Cell cell)` This method exists just to encapsulate how we serialize keys.
`static byte`	`getQualifierByte(Cell cell, int index)`
`static int`	`getRowAsInt(Cell cell)` Converts the rowkey bytes of the given cell into an int value n * @return rowkey as int
`static byte`	`getRowByte(Cell cell, int index)` misc
`static Optional<Tag>`	`getTag(Cell cell, byte type)` Retrieve Cell's first tag, matching the passed in type
`static List<Tag>`	`getTags(Cell cell)` Return tags in the given Cell as a List
`static BigDecimal`	`getValueAsBigDecimal(Cell cell)` Converts the value bytes of the given cell into a BigDecimal n * @return value as BigDecimal
`static double`	`getValueAsDouble(Cell cell)` Converts the value bytes of the given cell into a double value n * @return value as double
`static int`	`getValueAsInt(Cell cell)` Converts the value bytes of the given cell into a int value n * @return value as int
`static long`	`getValueAsLong(Cell cell)` Converts the value bytes of the given cell into a long value n * @return value as long
`static ByteBuffer`	`getValueBufferShallowCopy(Cell cell)`
`static boolean`	`isDelete(byte type)` Return true if a delete type, a `KeyValue.Type.Delete` or a {KeyValue.Type#DeleteFamily} or a `KeyValue.Type.DeleteColumn` KeyValue type.
`static boolean`	`isDeleteColumnOrFamily(Cell cell)` Returns True if this cell is a delete family or column type.
`static boolean`	`isDeleteColumns(Cell cell)`
`static boolean`	`isDeleteColumnVersion(Cell cell)`
`static boolean`	`isDeleteFamily(Cell cell)`
`static boolean`	`isDeleteFamilyVersion(Cell cell)`
`static boolean`	`isDeleteType(Cell cell)` Returns True if this cell is a `KeyValue.Type.Delete` type.
`static boolean`	`matchingColumn(Cell left, byte[] fam, int foffset, int flength, byte[] qual, int qoffset, int qlength)`
`static boolean`	`matchingFamily(Cell left, byte[] buf, int offset, int length)`
`static boolean`	`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`	`matchingRows(Cell left, byte[] buf, int offset, int length)`
`static boolean`	`matchingTags(Cell left, Cell right, int llength, int rlength)`
`static boolean`	`matchingType(Cell a, Cell b)`
`static boolean`	`matchingValue(Cell left, Cell right, int lvlength, int rvlength)`
`static boolean`	`overlappingKeys(byte[] start1, byte[] end1, byte[] start2, byte[] end2)` Returns true if the first range start1...end1 overlaps with the second range start2...end2, assuming the byte arrays represent row keys
`static boolean`	`qualifierStartsWith(Cell left, byte[] startsWith)` Finds if the start of the qualifier part of the Cell matches `buf`
`static void`	`setSequenceId(Cell cell, long seqId)` Sets the given seqId to the cell.
`static void`	`setTimestamp(Cell cell, byte[] ts)` Sets the given timestamp to the cell.
`static void`	`setTimestamp(Cell cell, long ts)` Sets the given timestamp to the cell.
`static Iterator<Tag>`	`tagsIterator(ByteBuffer tags, int offset, int length)`
`static Iterator<Tag>`	`tagsIterator(Cell cell)` Utility method to iterate through the tags in the given cell.
`static Cell.Type`	`toType(byte type)`
`static KeyValue.Type`	`toTypeByte(Cell.Type type)`
`static boolean`	`updateLatestStamp(Cell cell, byte[] ts)` Sets the given timestamp to the cell iff current timestamp is `HConstants.LATEST_TIMESTAMP`.
`static boolean`	`updateLatestStamp(Cell cell, long ts)` Sets the given timestamp to the cell iff current timestamp is `HConstants.LATEST_TIMESTAMP`.
`static int`	`writeCell(Cell cell, OutputStream out, boolean withTags)` Writes the cell to the given OutputStream
`static void`	`writeCellToBuffer(Cell cell, ByteBuffer buf, int offset)` Writes a cell to the buffer at the given offset
`static void`	`writeFamily(OutputStream out, Cell cell, byte flength)` Writes the family from the given cell to the output stream
`static void`	`writeFlatKey(Cell cell, DataOutput out)` Writes the Cell's key part as it would have serialized in a KeyValue.
`static int`	`writeFlatKey(Cell cell, OutputStream out)`
`static void`	`writeQualifier(OutputStream out, Cell cell, int qlength)` Writes the qualifier from the given cell to the output stream
`static void`	`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`	`writeRow(OutputStream out, Cell cell, short rlength)` Writes the row from the given cell to the output stream
`static void`	`writeRowKeyExcludingCommon(Cell cell, short rLen, int commonPrefix, DataOutputStream out)` Write rowkey excluding the common part.
`static void`	`writeRowSkippingBytes(DataOutputStream out, Cell cell, short rlength, int commonPrefix)` Writes the row from the given cell to the output stream excluding the common prefix
`static void`	`writeTags(OutputStream out, Cell cell, int tagsLength)` Writes the tag from the given cell to the output stream
`static void`	`writeValue(OutputStream out, Cell cell, int vlength)` Writes the value from the given cell to the output stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- PrivateCellUtil
```
private PrivateCellUtil()
```
  Private constructor to keep this class from being instantiated.

Method Detail

fillRowRange

public static ByteRange fillRowRange(Cell cell,
                                     ByteRange range)

ByteRange

fillFamilyRange

public static ByteRange fillFamilyRange(Cell cell,
                                        ByteRange range)

fillQualifierRange

public static ByteRange fillQualifierRange(Cell cell,
                                           ByteRange range)

fillValueRange

public static ByteRange fillValueRange(Cell cell,
                                       ByteRange range)

fillTagRange

public static ByteRange fillTagRange(Cell cell,
                                     ByteRange range)

getRowByte

public static byte getRowByte(Cell cell,
                              int index)

misc

getQualifierByte

public static byte getQualifierByte(Cell cell,
                                    int index)

getValueBufferShallowCopy

public static ByteBuffer getValueBufferShallowCopy(Cell cell)

createCell

public static Cell createCell(Cell cell,
                              List<Tag> tags)

Returns A new cell which is having the extra tags also added to it.

createCell

public static Cell createCell(Cell cell,
                              byte[] tags)

Returns A new cell which is having the extra tags also added to it.

createCell

public static Cell createCell(Cell cell,
                              byte[] value,
                              byte[] tags)

matchingRows

public static boolean matchingRows(Cell left,
                                   byte[] buf,
                                   int offset,
                                   int length)

matchingFamily

public static boolean matchingFamily(Cell left,
                                     byte[] buf,
                                     int offset,
                                     int length)

matchingQualifier
```
public static boolean matchingQualifier(Cell left,
                                        byte[] buf,
                                        int offset,
                                        int length)
```
Finds if the qualifier part of the cell and the KV serialized byte[] are equal

Parameters:

left - the cell with which we need to match the qualifier

buf - the serialized keyvalue format byte[]

offset - the offset of the qualifier in the byte[]

length - the length of the qualifier in the byte[]

Returns:

true if the qualifier matches, false otherwise

qualifierStartsWith
```
public static boolean qualifierStartsWith(Cell left,
                                          byte[] startsWith)
```
Finds if the start of the qualifier part of the Cell matches buf

Parameters:

left - the cell with which we need to match the qualifier

startsWith - the serialized keyvalue format byte[]

Returns:

true if the qualifier have same staring characters, false otherwise

matchingColumn

public static boolean matchingColumn(Cell left,
                                     byte[] fam,
                                     int foffset,
                                     int flength,
                                     byte[] qual,
                                     int qoffset,
                                     int qlength)

matchingValue

public static boolean matchingValue(Cell left,
                                    Cell right,
                                    int lvlength,
                                    int rvlength)

matchingType

public static boolean matchingType(Cell a,
                                   Cell b)

matchingTags

public static boolean matchingTags(Cell left,
                                   Cell right,
                                   int llength,
                                   int rlength)

isDelete
```
public static boolean isDelete(byte type)
```
Return true if a delete type, a KeyValue.Type.Delete or a {KeyValue.Type#DeleteFamily} or a KeyValue.Type.DeleteColumn KeyValue type.

isDeleteType
```
public static boolean isDeleteType(Cell cell)
```
Returns True if this cell is a KeyValue.Type.Delete type.

isDeleteFamily

public static boolean isDeleteFamily(Cell cell)

isDeleteFamilyVersion

public static boolean isDeleteFamilyVersion(Cell cell)

isDeleteColumns

public static boolean isDeleteColumns(Cell cell)

isDeleteColumnVersion

public static boolean isDeleteColumnVersion(Cell cell)

isDeleteColumnOrFamily
```
public static boolean isDeleteColumnOrFamily(Cell cell)
```
Returns True if this cell is a delete family or column type.

cloneTags

public static byte[] cloneTags(Cell cell)

copyTagsTo

public static int copyTagsTo(Cell cell,
                             byte[] destination,
                             int destinationOffset)

Copies the tags info into the tag portion of the cell

copyTagsTo

public static int copyTagsTo(Cell cell,
                             ByteBuffer destination,
                             int destinationOffset)

Copies the tags info into the tag portion of the cell

getTags
```
public static List<Tag> getTags(Cell cell)
```
Return tags in the given Cell as a List

Parameters:

cell - The Cell

Returns:

Tags in the given Cell as a List

getTag
```
public static Optional<Tag> getTag(Cell cell,
                                   byte type)
```
Retrieve Cell's first tag, matching the passed in type

Parameters:

cell - The Cell

type - Type of the Tag to retrieve

Returns:

Optional, empty if there is no tag of the passed in tag type

tagsIterator
```
public static Iterator<Tag> tagsIterator(Cell cell)
```
Utility method to iterate through the tags in the given cell.

Parameters:

cell - The Cell over which tags iterator is needed.

Returns:

iterator for the tags

tagsIterator

public static Iterator<Tag> tagsIterator(ByteBuffer tags,
                                         int offset,
                                         int length)

overlappingKeys

public static boolean overlappingKeys(byte[] start1,
                                      byte[] end1,
                                      byte[] start2,
                                      byte[] end2)

Returns true if the first range start1...end1 overlaps with the second range start2...end2, assuming the byte arrays represent row keys

writeRowKeyExcludingCommon

public static void writeRowKeyExcludingCommon(Cell cell,
                                              short rLen,
                                              int commonPrefix,
                                              DataOutputStream out)
                                       throws IOException

Write rowkey excluding the common part.

Throws:: IOException

writeRowSkippingBytes

public static void writeRowSkippingBytes(DataOutputStream out,
                                         Cell cell,
                                         short rlength,
                                         int commonPrefix)
                                  throws IOException

Writes the row from the given cell to the output stream excluding the common prefix

Parameters:: out - The dataoutputstream to which the data has to be written; cell - The cell whose contents has to be written; rlength - the row length n
Throws:: IOException

findCommonPrefixInFlatKey
```
public static int findCommonPrefixInFlatKey(Cell c1,
                                            Cell c2,
                                            boolean bypassFamilyCheck,
                                            boolean withTsType)
```
Find length of common prefix in keys of the cells, considering key as byte[] if serialized in KeyValue. The key format is <2 bytes rk len><rk><1 byte cf len><cf><qualifier><8 bytes timestamp><1 byte type>

Parameters:

c1 - the cell

c2 - the cell

bypassFamilyCheck - when true assume the family bytes same in both cells. Pass it as true when dealing with Cells in same CF so as to avoid some checks

withTsType - when true check timestamp and type bytes also.

Returns:

length of common prefix

compareKeyBasedOnColHint
```
public static final int compareKeyBasedOnColHint(CellComparator comparator,
                                                 Cell nextIndexedCell,
                                                 Cell currentCell,
                                                 int foff,
                                                 int flen,
                                                 byte[] colHint,
                                                 int coff,
                                                 int clen,
                                                 long ts,
                                                 byte type)
```
Used to compare two cells based on the column hint provided. This is specifically used when we need to optimize the seeks based on the next indexed key. This is an advanced usage API specifically needed for some optimizations.

Parameters:

nextIndexedCell - the next indexed cell

currentCell - the cell to be compared

foff - the family offset of the currentCell

flen - the family length of the currentCell

colHint - the column hint provided - could be null

coff - the offset of the column hint if provided, if not offset of the currentCell's qualifier

clen - the length of the column hint if provided, if not length of the currentCell's qualifier

ts - the timestamp to be seeked

type - the type to be seeked

Returns:

an int based on the given column hint TODO : To be moved out of here because this is a special API used in scan optimization.

compareKeyIgnoresMvcc

public static final int compareKeyIgnoresMvcc(CellComparator comparator,
                                              Cell left,
                                              Cell right)

Compares only the key portion of a cell. It does not include the sequence id/mvcc of the cell nn

Returns:: an int greater than 0 if left > than right lesser than 0 if left < than right equal to 0 if left is equal to right

compareRow
```
public static int compareRow(Cell cell,
                             ByteArrayComparable comparator)
```
Compare cell's row against given comparator

Parameters:

cell - the cell to use for comparison

comparator - the CellComparator to use for comparison

Returns:

result comparing cell's row

compareFamily
```
public static int compareFamily(Cell cell,
                                ByteArrayComparable comparator)
```
Compare cell's column family against given comparator

Parameters:

cell - the cell to use for comparison

comparator - the CellComparator to use for comparison

Returns:

result comparing cell's column family

compareQualifier
```
public static int compareQualifier(Cell cell,
                                   ByteArrayComparable comparator)
```
Compare cell's qualifier against given comparator

Parameters:

cell - the cell to use for comparison

comparator - the CellComparator to use for comparison

Returns:

result comparing cell's qualifier

toType

public static Cell.Type toType(byte type)

toTypeByte

public static KeyValue.Type toTypeByte(Cell.Type type)

compareValue
```
public static int compareValue(Cell cell,
                               ByteArrayComparable comparator)
```
Compare cell's value against given comparator

Parameters:

cell - the cell to use for comparison

comparator - the CellComparator to use for comparison

Returns:

result comparing cell's value

writeFlatKey
```
public static void writeFlatKey(Cell cell,
                                DataOutput out)
                         throws IOException
```
Writes the Cell's key part as it would have serialized in a KeyValue. The format is <2 bytes rk len><rk><1 byte cf len><cf><qualifier><8 bytes timestamp><1 byte type> nnn

Throws:

IOException

deepClone
```
public static Cell deepClone(Cell cell)
                      throws CloneNotSupportedException
```
Deep clones the given cell if the cell supports deep cloning

Parameters:

cell - the cell to be cloned

Returns:

the cloned cell n

Throws:

CloneNotSupportedException

writeCell

public static int writeCell(Cell cell,
                            OutputStream out,
                            boolean withTags)
                     throws IOException

Writes the cell to the given OutputStream

Parameters:: cell - the cell to be written; out - the outputstream; withTags - if tags are to be written or not
Returns:: the total bytes written n
Throws:: IOException

writeCellToBuffer
```
public static void writeCellToBuffer(Cell cell,
                                     ByteBuffer buf,
                                     int offset)
```
Writes a cell to the buffer at the given offset

Parameters:

cell - the cell to be written

buf - the buffer to which the cell has to be wrriten

offset - the offset at which the cell should be written

writeFlatKey

public static int writeFlatKey(Cell cell,
                               OutputStream out)
                        throws IOException

Throws:: IOException

setSequenceId
```
public static void setSequenceId(Cell cell,
                                 long seqId)
                          throws IOException
```
Sets the given seqId to the cell. Marked as audience Private as of 1.2.0. Setting a Cell sequenceid is an internal implementation detail not for general public use. nn * @throws IOException when the passed cell is not of type ExtendedCell

Throws:

IOException

setTimestamp
```
public static void setTimestamp(Cell cell,
                                long ts)
                         throws IOException
```
Sets the given timestamp to the cell. nn * @throws IOException when the passed cell is not of type ExtendedCell

Throws:

IOException

setTimestamp

public static void setTimestamp(Cell cell,
                                byte[] ts)
                         throws IOException

Sets the given timestamp to the cell.

Throws:: IOException - when the passed cell is not of type ExtendedCell

updateLatestStamp
```
public static boolean updateLatestStamp(Cell cell,
                                        long ts)
                                 throws IOException
```
Sets the given timestamp to the cell iff current timestamp is HConstants.LATEST_TIMESTAMP.

Returns:

True if cell timestamp is modified.

Throws:

IOException - when the passed cell is not of type ExtendedCell

updateLatestStamp
```
public static boolean updateLatestStamp(Cell cell,
                                        byte[] ts)
                                 throws IOException
```
Sets the given timestamp to the cell iff current timestamp is HConstants.LATEST_TIMESTAMP.

Returns:

True if cell timestamp is modified.

Throws:

IOException - when the passed cell is not of type ExtendedCell

writeRow
```
public static void writeRow(OutputStream out,
                            Cell cell,
                            short rlength)
                     throws IOException
```
Writes the row from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

rlength - the row length n

Throws:

IOException

writeFamily
```
public static void writeFamily(OutputStream out,
                               Cell cell,
                               byte flength)
                        throws IOException
```
Writes the family from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

flength - the family length n

Throws:

IOException

writeQualifier
```
public static void writeQualifier(OutputStream out,
                                  Cell cell,
                                  int qlength)
                           throws IOException
```
Writes the qualifier from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

qlength - the qualifier length n

Throws:

IOException

writeQualifierSkippingBytes

public static void writeQualifierSkippingBytes(DataOutputStream out,
                                               Cell cell,
                                               int qlength,
                                               int commonPrefix)
                                        throws IOException

Writes the qualifier from the given cell to the output stream excluding the common prefix

Parameters:: out - The dataoutputstream to which the data has to be written; cell - The cell whose contents has to be written; qlength - the qualifier length n
Throws:: IOException

writeValue
```
public static void writeValue(OutputStream out,
                              Cell cell,
                              int vlength)
                       throws IOException
```
Writes the value from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

vlength - the value length n

Throws:

IOException

writeTags
```
public static void writeTags(OutputStream out,
                             Cell cell,
                             int tagsLength)
                      throws IOException
```
Writes the tag from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

tagsLength - the tag length n

Throws:

IOException

equalsIgnoreMvccVersion

public static boolean equalsIgnoreMvccVersion(Cell a,
                                              Cell b)

special case for Cell.equals

getRowAsInt
```
public static int getRowAsInt(Cell cell)
```
Converts the rowkey bytes of the given cell into an int value n * @return rowkey as int

getValueAsLong
```
public static long getValueAsLong(Cell cell)
```
Converts the value bytes of the given cell into a long value n * @return value as long

getValueAsInt
```
public static int getValueAsInt(Cell cell)
```
Converts the value bytes of the given cell into a int value n * @return value as int

getValueAsDouble
```
public static double getValueAsDouble(Cell cell)
```
Converts the value bytes of the given cell into a double value n * @return value as double

getValueAsBigDecimal
```
public static BigDecimal getValueAsBigDecimal(Cell cell)
```
Converts the value bytes of the given cell into a BigDecimal n * @return value as BigDecimal

compressTags
```
public static void compressTags(OutputStream out,
                                Cell cell,
                                TagCompressionContext tagCompressionContext)
                         throws IOException
```
Compresses the tags to the given outputstream using the TagcompressionContext

Parameters:

out - the outputstream to which the compression should happen

cell - the cell which has tags

tagCompressionContext - the TagCompressionContext

Throws:

IOException - can throw IOException if the compression encounters issue

compressRow

public static void compressRow(OutputStream out,
                               Cell cell,
                               Dictionary dict)
                        throws IOException

Throws:: IOException

compressFamily

public static void compressFamily(OutputStream out,
                                  Cell cell,
                                  Dictionary dict)
                           throws IOException

Throws:: IOException

compressQualifier

public static void compressQualifier(OutputStream out,
                                     Cell cell,
                                     Dictionary dict)
                              throws IOException

Throws:: IOException

compare
```
public static final int compare(CellComparator comparator,
                                Cell left,
                                byte[] key,
                                int offset,
                                int length)
```
Used when a cell needs to be compared with a key byte[] such as cases of finding the index from the index block, bloom keys from the bloom blocks This byte[] is expected to be serialized in the KeyValue serialization format If the KeyValue (Cell's) serialization format changes this method cannot be used.

Parameters:

comparator - the CellComparator to use for comparison

left - the cell to be compared

key - the serialized key part of a KeyValue

offset - the offset in the key byte[]

length - the length of the key byte[]

Returns:

an int greater than 0 if left is greater than right lesser than 0 if left is lesser than right equal to 0 if left is equal to right

compareWithoutRow
```
static final int compareWithoutRow(CellComparator comparator,
                                   Cell left,
                                   byte[] right,
                                   int roffset,
                                   int rlength,
                                   short rowlength)
```
Compare columnFamily, qualifier, timestamp, and key type (everything except the row). This method is used both in the normal comparator and the "same-prefix" comparator. Note that we are assuming that row portions of both KVs have already been parsed and found identical, and we don't validate that assumption here.

Parameters:

comparator - the CellComparator to use for comparison

left - the cell to be compared

right - the serialized key part of a key-value

roffset - the offset in the key byte[]

rlength - the length of the key byte[]

rowlength - the row length

Returns:

greater than 0 if left cell is bigger, less than 0 if right cell is bigger, 0 if both cells are equal

createNextOnRowCol
```
public static Cell createNextOnRowCol(Cell cell)
```
Return a new cell is located following input cell. If both of type and timestamp are minimum, the input cell will be returned directly.

createNextOnRowCol

static Cell createNextOnRowCol(Cell cell,
                               long ts,
                               byte type)

estimatedSerializedSizeOf
```
public static int estimatedSerializedSizeOf(Cell cell)
```
Estimate based on keyvalue's serialization format in the RPC layer. Note that there is an extra SIZEOF_INT added to the size here that indicates the actual length of the cell for cases where cell's are serialized in a contiguous format (For eg in RPCs). n * @return Estimate of the cell size in bytes plus an extra SIZEOF_INT indicating the actual cell length.

estimatedSerializedSizeOfKey
```
public static int estimatedSerializedSizeOfKey(Cell cell)
```
Calculates the serialized key size. We always serialize in the KeyValue's serialization format.

Parameters:

cell - the cell for which the key size has to be calculated.

Returns:

the key size

getCellKeySerializedAsKeyValueKey
```
public static byte[] getCellKeySerializedAsKeyValueKey(Cell cell)
```
This method exists just to encapsulate how we serialize keys. To be replaced by a factory that we query to figure what the Cell implementation is and then, what serialization engine to use and further, how to serialize the key for inclusion in hfile index. TODO. n * @return The key portion of the Cell serialized in the old-school KeyValue way or null if passed a null cell

createFirstOnRow
```
public static Cell createFirstOnRow(Cell cell)
```
Create a Cell that is smaller than all other possible Cells for the given Cell's row. n * @return First possible Cell on passed Cell's row.

createFirstOnRow

public static Cell createFirstOnRow(byte[] row,
                                    int roffset,
                                    short rlength)

createFirstOnRow

public static Cell createFirstOnRow(byte[] row,
                                    byte[] family,
                                    byte[] col)

createFirstOnRow

public static Cell createFirstOnRow(byte[] row,
                                    int roffset,
                                    short rlength,
                                    byte[] family,
                                    int foffset,
                                    byte flength,
                                    byte[] col,
                                    int coffset,
                                    int clength)

createFirstOnRow

public static Cell createFirstOnRow(byte[] row)

createFirstOnRowFamily

public static Cell createFirstOnRowFamily(Cell cell,
                                          byte[] fArray,
                                          int foff,
                                          int flen)

createFirstOnRowCol

public static Cell createFirstOnRowCol(Cell cell)

createFirstOnNextRow

public static Cell createFirstOnNextRow(Cell cell)

createFirstOnRowCol

public static Cell 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. nnnn * @return Last possible Cell on passed Cell's rk:cf and passed qualifier.

createFirstOnRowColTS
```
public static Cell createFirstOnRowColTS(Cell cell,
                                         long ts)
```
Creates the first cell with the row/family/qualifier of this cell and the given timestamp. Uses the "maximum" type that guarantees that the new cell is the lowest possible for this combination of row, family, qualifier, and timestamp. This cell's own timestamp is ignored.

Parameters:

cell - - cell n

createLastOnRow
```
public static Cell createLastOnRow(Cell cell)
```
Create a Cell that is larger than all other possible Cells for the given Cell's row. n * @return Last possible Cell on passed Cell's row.

createLastOnRow

public static Cell createLastOnRow(byte[] row)

createLastOnRowCol
```
public static Cell createLastOnRowCol(Cell cell)
```
Create a Cell that is larger than all other possible Cells for the given Cell's rk:cf:q. Used in creating "fake keys" for the multi-column Bloom filter optimization to skip the row/column we already know is not in the file. n * @return Last possible Cell on passed Cell's rk:cf:q.

createFirstDeleteFamilyCellOnRow
```
public static Cell createFirstDeleteFamilyCellOnRow(byte[] row,
                                                    byte[] fam)
```
Create a Delete Family Cell for the specified row and family that would be smaller than all other possible Delete Family KeyValues that have the same row and family. Used for seeking.

Parameters:

row - - row key (arbitrary byte array)

fam - - family name

Returns:

First Delete Family possible key on passed row.

Class PrivateCellUtil

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PrivateCellUtil

Method Detail

fillRowRange

fillFamilyRange

fillQualifierRange

fillValueRange

fillTagRange

getRowByte

getQualifierByte

getValueBufferShallowCopy

createCell

createCell

createCell

matchingRows

matchingFamily

matchingQualifier

qualifierStartsWith

matchingColumn

matchingValue

matchingType

matchingTags

isDelete

isDeleteType

isDeleteFamily

isDeleteFamilyVersion

isDeleteColumns

isDeleteColumnVersion

isDeleteColumnOrFamily

cloneTags

copyTagsTo

copyTagsTo

getTags

getTag

tagsIterator

tagsIterator

overlappingKeys

writeRowKeyExcludingCommon

writeRowSkippingBytes

findCommonPrefixInFlatKey

compareKeyBasedOnColHint

compareKeyIgnoresMvcc

compareRow

compareFamily

compareQualifier

toType

toTypeByte

compareValue

writeFlatKey

deepClone

writeCell

writeCellToBuffer

writeFlatKey

setSequenceId

setTimestamp

setTimestamp

updateLatestStamp

updateLatestStamp

writeRow

writeFamily

writeQualifier

writeQualifierSkippingBytes

writeValue

writeTags

equalsIgnoreMvccVersion

getRowAsInt

getValueAsLong

getValueAsInt

getValueAsDouble

getValueAsBigDecimal

compressTags

compressRow

compressFamily

compressQualifier

compare