HFileBlock (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.io.hfile.HFileBlock

All Implemented Interfaces:

HeapSize, Cacheable
```
@InterfaceAudience.Private
public class HFileBlock
extends Object
implements Cacheable
```
Reading HFile version 1 and 2 blocks, and writing version 2 blocks.
- In version 1 all blocks are always compressed or uncompressed, as specified by the HFile's compression algorithm, with a type-specific magic record stored in the beginning of the compressed data (i.e. one needs to uncompress the compressed block to determine the block type). There is only a single compression algorithm setting for all blocks. Offset and size information from the block index are required to read a block.
- In version 2 a block is structured as follows:
  - header (see Writer#finishBlock())
    - Magic record identifying the block type (8 bytes)
    - Compressed block size, excluding header, including checksum (4 bytes)
    - Uncompressed block size, excluding header, excluding checksum (4 bytes)
    - The offset of the previous block of the same type (8 bytes). This is used to be able to navigate to the previous block without going to the block
    - For minorVersions >=1, the ordinal describing checksum type (1 byte)
    - For minorVersions >=1, the number of data bytes/checksum chunk (4 bytes)
    - For minorVersions >=1, the size of data on disk, including header, excluding checksums (4 bytes)
  - Raw/Compressed/Encrypted/Encoded data. The compression algorithm is the same for all the blocks in the HFile, similarly to what was done in version 1.
  - For minorVersions >=1, a series of 4 byte checksums, one each for the number of bytes specified by bytesPerChecksum.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`HFileBlock.AbstractFSReader` A common implementation of some methods of `HFileBlock.FSReader` and some tools for implementing HFile format version-specific block readers.
`static interface`	`HFileBlock.BlockIterator` An interface allowing to iterate `HFileBlock`s.
`static interface`	`HFileBlock.BlockWritable` Something that can be written into a block.
`static interface`	`HFileBlock.FSReader` A full-fledged reader with iteration ability.
`(package private) static class`	`HFileBlock.FSReaderImpl` Reads version 2 blocks from the filesystem.
`(package private) static class`	`HFileBlock.Header`
`private static class`	`HFileBlock.PrefetchedHeader` We always prefetch the header of the next block, so that we know its on-disk size in advance and can read it in one operation.
`static class`	`HFileBlock.Writer` Unified version 2 `HFile` block writer.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static CacheableDeserializer<Cacheable>`	`blockDeserializer`
`private BlockType`	`blockType` Type of block.
`private ByteBuffer`	`buf` The in-memory representation of the hfile block
`static int`	`BYTE_BUFFER_HEAP_SIZE`
`(package private) static int`	`CHECKSUM_SIZE` Each checksum value is an integer that can be stored in 4 bytes.
`(package private) static int`	`CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD` On a checksum failure on a Reader, these many suceeding read requests switch back to using hdfs checksums before auto-reenabling hbase checksum verification.
`private static int`	`deserializerIdentifier`
`static boolean`	`DONT_FILL_HEADER`
`(package private) static byte[]`	`DUMMY_HEADER_NO_CHECKSUM`
`static int`	`ENCODED_HEADER_SIZE` The size of block header when blockType is `BlockType.ENCODED_DATA`.
`static int`	`EXTRA_SERIALIZATION_SPACE`
`private HFileContext`	`fileContext` Meta data that holds meta information on the hfileblock
`static boolean`	`FILL_HEADER`
`private int`	`nextBlockOnDiskSizeWithHeader` The on-disk size of the next block, including the header, obtained by peeking into the first `HConstants.HFILEBLOCK_HEADER_SIZE` bytes of the next block's header, or -1 if unknown.
`private long`	`offset` The offset of this block in the file.
`private int`	`onDiskDataSizeWithHeader` Size on disk of header + data.
`private int`	`onDiskSizeWithoutHeader` Size on disk excluding header, including checksum.
`private long`	`prevBlockOffset` The offset of the previous block on disk.
`private int`	`uncompressedSizeWithoutHeader` Size of pure data.

Constructor Summary

Constructors
Constructor and Description
`HFileBlock(BlockType blockType, int onDiskSizeWithoutHeader, int uncompressedSizeWithoutHeader, long prevBlockOffset, ByteBuffer buf, boolean fillHeader, long offset, int onDiskDataSizeWithHeader, HFileContext fileContext)` Creates a new `HFile` block from the given fields.
`HFileBlock(ByteBuffer b, boolean usesHBaseChecksum)` Creates a block from an existing buffer starting with a header.
`HFileBlock(HFileBlock that)` Copy constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`private void`	`allocateBuffer()` Always allocates a new buffer of the correct size.
`boolean`	`equals(Object comparison)`
`void`	`expectType(BlockType expectedType)`
`BlockType`	`getBlockType()`
`ByteBuffer`	`getBufferReadOnly()` Returns the buffer this block stores internally.
`ByteBuffer`	`getBufferReadOnlyWithHeader()` Returns the buffer of this block, including header data.
`(package private) ByteBuffer`	`getBufferWithHeader()` Returns a byte buffer of this block, including header data and checksum, positioned at the beginning of header.
`ByteBuffer`	`getBufferWithoutHeader()` Returns a buffer that does not include the header or checksum.
`(package private) int`	`getBytesPerChecksum()`
`DataInputStream`	`getByteStream()`
`(package private) byte`	`getChecksumType()`
`DataBlockEncoding`	`getDataBlockEncoding()`
`short`	`getDataBlockEncodingId()`
`CacheableDeserializer<Cacheable>`	`getDeserializer()` Returns CacheableDeserializer instance which reconstructs original object from ByteBuffer.
`byte[]`	`getDummyHeaderForVersion()` Return the appropriate DUMMY_HEADER for the minor version
`private static byte[]`	`getDummyHeaderForVersion(boolean usesHBaseChecksum)` Return the appropriate DUMMY_HEADER for the minor version
`HFileContext`	`getHFileContext()`
`int`	`getNextBlockOnDiskSizeWithHeader()`
`long`	`getOffset()`
`(package private) int`	`getOnDiskDataSizeWithHeader()`
`int`	`getOnDiskSizeWithHeader()`
`int`	`getOnDiskSizeWithoutHeader()`
`long`	`getPrevBlockOffset()`
`int`	`getSerializedLength()` Returns the length of the ByteBuffer required to serialized the object.
`int`	`getUncompressedSizeWithoutHeader()`
`private boolean`	`hasNextBlockHeader()` Return true when this buffer includes next block's header.
`int`	`headerSize()` Returns the size of this block header.
`static int`	`headerSize(boolean usesHBaseChecksum)` Maps a minor version to the size of the header.
`long`	`heapSize()`
`boolean`	`isUnpacked()` Return true when this block's buffer has been unpacked, false otherwise.
`private void`	`overwriteHeader()` Rewinds `buf` and writes first 4 header fields.
`(package private) static boolean`	`positionalReadWithExtra(org.apache.hadoop.fs.FSDataInputStream in, long position, byte[] buf, int bufOffset, int necessaryLen, int extraLen)` Read from an input stream.
`static boolean`	`readWithExtra(InputStream in, byte[] buf, int bufOffset, int necessaryLen, int extraLen)` Read from an input stream.
`(package private) void`	`sanityCheck()` Checks if the block is internally consistent, i.e.
`private void`	`sanityCheckAssertion(BlockType valueFromBuf, BlockType valueFromField)`
`private void`	`sanityCheckAssertion(long valueFromBuf, long valueFromField, String fieldName)`
`void`	`serialize(ByteBuffer destination)` Serializes its data into destination.
`void`	`serializeExtraInfo(ByteBuffer destination)`
`String`	`toString()`
`(package private) static String`	`toStringHeader(ByteBuffer buf)` Convert the contents of the block header into a human readable string.
`(package private) int`	`totalChecksumBytes()` Calculate the number of bytes required to store all the checksums for this block.
`private static int`	`totalChecksumBytes(HFileContext fileContext, int onDiskDataSizeWithHeader)`
`(package private) HFileBlock`	`unpack(HFileContext fileContext, HFileBlock.FSReader reader)` Retrieves the decompressed/decrypted view of this block.
`private static void`	`validateOnDiskSizeWithoutHeader(int expectedOnDiskSizeWithoutHeader, int actualOnDiskSizeWithoutHeader, ByteBuffer buf, long offset)` Called after reading a block with provided onDiskSizeWithHeader.
`static void`	`verifyUncompressed(ByteBuffer buf, boolean useHBaseChecksum)` An additional sanity-check in case no compression or encryption is being used.

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

- Field Detail
  - CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD
```
static final int CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD
```
    On a checksum failure on a Reader, these many suceeding read requests switch back to using hdfs checksums before auto-reenabling hbase checksum verification.
    
    See Also:
    Constant Field Values
  - FILL_HEADER
```
public static final boolean FILL_HEADER
```
    See Also:
    Constant Field Values
  - DONT_FILL_HEADER
```
public static final boolean DONT_FILL_HEADER
```
    See Also:
    Constant Field Values
  - ENCODED_HEADER_SIZE
```
public static final int ENCODED_HEADER_SIZE
```
    The size of block header when blockType is BlockType.ENCODED_DATA. This extends normal header by adding the id of encoder.
    
    See Also:
    Constant Field Values
  - DUMMY_HEADER_NO_CHECKSUM
```
static final byte[] DUMMY_HEADER_NO_CHECKSUM
```
  - BYTE_BUFFER_HEAP_SIZE
```
public static final int BYTE_BUFFER_HEAP_SIZE
```
  - EXTRA_SERIALIZATION_SPACE
```
public static final int EXTRA_SERIALIZATION_SPACE
```
    See Also:
    Constant Field Values
  - CHECKSUM_SIZE
```
static final int CHECKSUM_SIZE
```
    Each checksum value is an integer that can be stored in 4 bytes.
    
    See Also:
    Constant Field Values
  - blockDeserializer
```
static final CacheableDeserializer<Cacheable> blockDeserializer
```
  - deserializerIdentifier
```
private static final int deserializerIdentifier
```
  - blockType
```
private BlockType blockType
```
    Type of block. Header field 0.
  - onDiskSizeWithoutHeader
```
private int onDiskSizeWithoutHeader
```
    Size on disk excluding header, including checksum. Header field 1.
  - uncompressedSizeWithoutHeader
```
private final int uncompressedSizeWithoutHeader
```
    Size of pure data. Does not include header or checksums. Header field 2.
  - prevBlockOffset
```
private final long prevBlockOffset
```
    The offset of the previous block on disk. Header field 3.
  - onDiskDataSizeWithHeader
```
private final int onDiskDataSizeWithHeader
```
    Size on disk of header + data. Excludes checksum. Header field 6, OR calculated from onDiskSizeWithoutHeader when using HDFS checksum.
  - buf
```
private ByteBuffer buf
```
    The in-memory representation of the hfile block
  - fileContext
```
private HFileContext fileContext
```
    Meta data that holds meta information on the hfileblock
  - offset
```
private long offset
```
    The offset of this block in the file. Populated by the reader for convenience of access. This offset is not part of the block header.
  - nextBlockOnDiskSizeWithHeader
```
private int nextBlockOnDiskSizeWithHeader
```
    The on-disk size of the next block, including the header, obtained by peeking into the first HConstants.HFILEBLOCK_HEADER_SIZE bytes of the next block's header, or -1 if unknown.
- Constructor Detail
  - HFileBlock
```
HFileBlock(BlockType blockType,
          int onDiskSizeWithoutHeader,
          int uncompressedSizeWithoutHeader,
          long prevBlockOffset,
          ByteBuffer buf,
          boolean fillHeader,
          long offset,
          int onDiskDataSizeWithHeader,
          HFileContext fileContext)
```
    Creates a new HFile block from the given fields. This constructor is mostly used when the block data has already been read and uncompressed, and is sitting in a byte buffer.
    
    Parameters:
    blockType - the type of this block, see BlockType
    onDiskSizeWithoutHeader - see onDiskSizeWithoutHeader
    uncompressedSizeWithoutHeader - see uncompressedSizeWithoutHeader
    prevBlockOffset - see prevBlockOffset
    buf - block header (HConstants.HFILEBLOCK_HEADER_SIZE bytes) followed by uncompressed data. This
    fillHeader - when true, parse buf and override the first 4 header fields.
    offset - the file offset the block was read from
    onDiskDataSizeWithHeader - see onDiskDataSizeWithHeader
    fileContext - HFile meta data
  - HFileBlock
```
HFileBlock(HFileBlock that)
```
    Copy constructor. Creates a shallow copy of that's buffer.
  - HFileBlock
```
HFileBlock(ByteBuffer b,
          boolean usesHBaseChecksum)
     throws IOException
```
    Creates a block from an existing buffer starting with a header. Rewinds and takes ownership of the buffer. By definition of rewind, ignores the buffer position, but if you slice the buffer beforehand, it will rewind to that point. The reason this has a minorNumber and not a majorNumber is because majorNumbers indicate the format of a HFile whereas minorNumbers indicate the format inside a HFileBlock.
    
    Throws:
    
    IOException
- Method Detail
  - getBlockType
```
public BlockType getBlockType()
```
    Specified by:
    
    getBlockType in interface Cacheable
    
    Returns:
    the block type of this cached HFile block
  - getDataBlockEncodingId
```
public short getDataBlockEncodingId()
```
    Returns:
    get data block encoding id that was used to encode this block
  - getOnDiskSizeWithHeader
```
public int getOnDiskSizeWithHeader()
```
    Returns:
    the on-disk size of header + data part + checksum.
  - getOnDiskSizeWithoutHeader
```
public int getOnDiskSizeWithoutHeader()
```
    Returns:
    the on-disk size of the data part + checksum (header excluded).
  - getUncompressedSizeWithoutHeader
```
public int getUncompressedSizeWithoutHeader()
```
    Returns:
    the uncompressed size of data part (header and checksum excluded).
  - getPrevBlockOffset
```
public long getPrevBlockOffset()
```
    Returns:
    the offset of the previous block of the same type in the file, or -1 if unknown
  - overwriteHeader
```
private void overwriteHeader()
```
    Rewinds buf and writes first 4 header fields. buf position is modified as side-effect.
  - getBufferWithoutHeader
```
public ByteBuffer getBufferWithoutHeader()
```
    Returns a buffer that does not include the header or checksum.
    
    Returns:
    the buffer with header skipped and checksum omitted.
  - getBufferReadOnly
```
public ByteBuffer getBufferReadOnly()
```
    Returns the buffer this block stores internally. The clients must not modify the buffer object. This method has to be public because it is used in CompoundBloomFilter to avoid object creation on every Bloom filter lookup, but has to be used with caution. Checksum data is not included in the returned buffer but header data is.
    
    Returns:
    the buffer of this block for read-only operations
  - getBufferReadOnlyWithHeader
```
public ByteBuffer getBufferReadOnlyWithHeader()
```
    Returns the buffer of this block, including header data. The clients must not modify the buffer object. This method has to be public because it is used in BucketCache to avoid buffer copy.
    
    Returns:
    the buffer with header and checksum included for read-only operations
  - getBufferWithHeader
```
ByteBuffer getBufferWithHeader()
```
    Returns a byte buffer of this block, including header data and checksum, positioned at the beginning of header. The underlying data array is not copied.
    
    Returns:
    the byte buffer with header and checksum included
  - sanityCheckAssertion
```
private void sanityCheckAssertion(long valueFromBuf,
                        long valueFromField,
                        String fieldName)
                           throws IOException
```
    Throws:
    
    IOException
  - sanityCheckAssertion
```
private void sanityCheckAssertion(BlockType valueFromBuf,
                        BlockType valueFromField)
                           throws IOException
```
    Throws:
    
    IOException
  - sanityCheck
```
void sanityCheck()
           throws IOException
```
    Checks if the block is internally consistent, i.e. the first HConstants.HFILEBLOCK_HEADER_SIZE bytes of the buffer contain a valid header consistent with the fields. Assumes a packed block structure. This function is primary for testing and debugging, and is not thread-safe, because it alters the internal buffer pointer.
    
    Throws:
    
    IOException
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - validateOnDiskSizeWithoutHeader
```
private static void validateOnDiskSizeWithoutHeader(int expectedOnDiskSizeWithoutHeader,
                                   int actualOnDiskSizeWithoutHeader,
                                   ByteBuffer buf,
                                   long offset)
                                             throws IOException
```
    Called after reading a block with provided onDiskSizeWithHeader.
    
    Throws:
    
    IOException
  - unpack
```
HFileBlock unpack(HFileContext fileContext,
                HFileBlock.FSReader reader)
            throws IOException
```
    Retrieves the decompressed/decrypted view of this block. An encoded block remains in its encoded structure. Internal structures are shared between instances where applicable.
    
    Throws:
    
    IOException
  - hasNextBlockHeader
```
private boolean hasNextBlockHeader()
```
    Return true when this buffer includes next block's header.
  - allocateBuffer
```
private void allocateBuffer()
```
    Always allocates a new buffer of the correct size. Copies header bytes from the existing buffer. Does not change header fields. Reserve room to keep checksum bytes too.
  - isUnpacked
```
public boolean isUnpacked()
```
    Return true when this block's buffer has been unpacked, false otherwise. Note this is a calculated heuristic, not tracked attribute of the block.
  - verifyUncompressed
```
public static void verifyUncompressed(ByteBuffer buf,
                      boolean useHBaseChecksum)
                               throws IOException
```
    An additional sanity-check in case no compression or encryption is being used.
    
    Throws:
    
    IOException
  - expectType
```
public void expectType(BlockType expectedType)
                throws IOException
```
    Parameters:
    expectedType - the expected type of this block
    
    Throws:
    
    IOException - if this block's type is different than expected
  - getOffset
```
public long getOffset()
```
    Returns:
    the offset of this block in the file it was read from
  - getByteStream
```
public DataInputStream getByteStream()
```
    Returns:
    a byte stream reading the data + checksum of this block
  - heapSize
```
public long heapSize()
```
    Specified by:
    
    heapSize in interface HeapSize
    
    Returns:
    Approximate 'exclusive deep size' of implementing object. Includes count of payload and hosting object sizings.
  - readWithExtra
```
public static boolean readWithExtra(InputStream in,
                    byte[] buf,
                    int bufOffset,
                    int necessaryLen,
                    int extraLen)
                             throws IOException
```
    Read from an input stream. Analogous to IOUtils.readFully(InputStream, byte[], int, int), but specifies a number of "extra" bytes that would be desirable but not absolutely necessary to read.
    
    Parameters:
    in - the input stream to read from
    buf - the buffer to read into
    bufOffset - the destination offset in the buffer
    necessaryLen - the number of bytes that are absolutely necessary to read
    extraLen - the number of extra bytes that would be nice to read
    
    Returns:
    true if succeeded reading the extra bytes
    
    Throws:
    
    IOException - if failed to read the necessary bytes
  - positionalReadWithExtra
```
static boolean positionalReadWithExtra(org.apache.hadoop.fs.FSDataInputStream in,
                              long position,
                              byte[] buf,
                              int bufOffset,
                              int necessaryLen,
                              int extraLen)
                                throws IOException
```
    Read from an input stream. Analogous to IOUtils.readFully(InputStream, byte[], int, int), but uses positional read and specifies a number of "extra" bytes that would be desirable but not absolutely necessary to read.
    
    Parameters:
    in - the input stream to read from
    position - the position within the stream from which to start reading
    buf - the buffer to read into
    bufOffset - the destination offset in the buffer
    necessaryLen - the number of bytes that are absolutely necessary to read
    extraLen - the number of extra bytes that would be nice to read
    
    Returns:
    true if and only if extraLen is > 0 and reading those extra bytes was successful
    
    Throws:
    
    IOException - if failed to read the necessary bytes
  - getNextBlockOnDiskSizeWithHeader
```
public int getNextBlockOnDiskSizeWithHeader()
```
    Returns:
    the on-disk size of the next block (including the header size) that was read by peeking into the next block's header
  - getSerializedLength
```
public int getSerializedLength()
```
    Description copied from interface: Cacheable
    
    Returns the length of the ByteBuffer required to serialized the object. If the object cannot be serialized, it should return 0.
    
    Specified by:
    
    getSerializedLength in interface Cacheable
    
    Returns:
    int length in bytes of the serialized form or 0 if the object cannot be cached.
  - serialize
```
public void serialize(ByteBuffer destination)
```
    Description copied from interface: Cacheable
    
    Serializes its data into destination.
    
    Specified by:
    
    serialize in interface Cacheable
    
    Parameters:
    destination - Where to serialize to
  - serializeExtraInfo
```
public void serializeExtraInfo(ByteBuffer destination)
```
  - getDeserializer
```
public CacheableDeserializer<Cacheable> getDeserializer()
```
    Description copied from interface: Cacheable
    
    Returns CacheableDeserializer instance which reconstructs original object from ByteBuffer.
    
    Specified by:
    
    getDeserializer in interface Cacheable
    
    Returns:
    CacheableDeserialzer instance.
  - equals
```
public boolean equals(Object comparison)
```
    Overrides:
    
    equals in class Object
  - getDataBlockEncoding
```
public DataBlockEncoding getDataBlockEncoding()
```
  - getChecksumType
```
byte getChecksumType()
```
  - getBytesPerChecksum
```
int getBytesPerChecksum()
```
  - getOnDiskDataSizeWithHeader
```
int getOnDiskDataSizeWithHeader()
```
    Returns:
    the size of data on disk + header. Excludes checksum.
  - totalChecksumBytes
```
int totalChecksumBytes()
```
    Calculate the number of bytes required to store all the checksums for this block. Each checksum value is a 4 byte integer (CHECKSUM_SIZE).
  - totalChecksumBytes
```
private static int totalChecksumBytes(HFileContext fileContext,
                     int onDiskDataSizeWithHeader)
```
  - headerSize
```
public int headerSize()
```
    Returns the size of this block header.
  - headerSize
```
public static int headerSize(boolean usesHBaseChecksum)
```
    Maps a minor version to the size of the header.
  - getDummyHeaderForVersion
```
public byte[] getDummyHeaderForVersion()
```
    Return the appropriate DUMMY_HEADER for the minor version
  - getDummyHeaderForVersion
```
private static byte[] getDummyHeaderForVersion(boolean usesHBaseChecksum)
```
    Return the appropriate DUMMY_HEADER for the minor version
  - getHFileContext
```
public HFileContext getHFileContext()
```
    Returns:
    the HFileContext used to create this HFileBlock. Not necessary the fileContext for the file from which this block's data was originally read.
  - toStringHeader
```
static String toStringHeader(ByteBuffer buf)
                      throws IOException
```
    Convert the contents of the block header into a human readable string. This is mostly helpful for debugging. This assumes that the block has minor version > 0.
    
    Throws:
    
    IOException

Class HFileBlock

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CHECKSUM_VERIFICATION_NUM_IO_THRESHOLD

FILL_HEADER

DONT_FILL_HEADER

ENCODED_HEADER_SIZE

DUMMY_HEADER_NO_CHECKSUM

BYTE_BUFFER_HEAP_SIZE

EXTRA_SERIALIZATION_SPACE

CHECKSUM_SIZE

blockDeserializer

deserializerIdentifier

blockType

onDiskSizeWithoutHeader

uncompressedSizeWithoutHeader

prevBlockOffset

onDiskDataSizeWithHeader

buf

fileContext

offset

nextBlockOnDiskSizeWithHeader

Constructor Detail

HFileBlock

HFileBlock

HFileBlock

Method Detail

getBlockType

getDataBlockEncodingId

getOnDiskSizeWithHeader

getOnDiskSizeWithoutHeader

getUncompressedSizeWithoutHeader

getPrevBlockOffset

overwriteHeader

getBufferWithoutHeader

getBufferReadOnly

getBufferReadOnlyWithHeader

getBufferWithHeader

sanityCheckAssertion

sanityCheckAssertion

sanityCheck

toString

validateOnDiskSizeWithoutHeader

unpack

hasNextBlockHeader

allocateBuffer

isUnpacked

verifyUncompressed

expectType

getOffset

getByteStream

heapSize

readWithExtra

positionalReadWithExtra

getNextBlockOnDiskSizeWithHeader

getSerializedLength

serialize

serializeExtraInfo

getDeserializer

equals

getDataBlockEncoding

getChecksumType

getBytesPerChecksum

getOnDiskDataSizeWithHeader

totalChecksumBytes

totalChecksumBytes

headerSize

headerSize

getDummyHeaderForVersion

getDummyHeaderForVersion

getHFileContext

toStringHeader