Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.commons.compress.archivers.tar
Class TarUtils

    java.lang.Object
      org.apache.commons.compress.archivers.tar.TarUtils

    public class TarUtils

extends Object

This class provides static utility methods to work with byte streams.

This class is immutable

Method Summary
`static long` | `computeCheckSum(byte[] buf)` Compute the checksum of a tar entry header.
`static int` | `formatCheckSumOctalBytes(long value, byte[] buf, int offset, int length)` Writes an octal value into a buffer.
`static int` | `formatLongOctalBytes(long value, byte[] buf, int offset, int length)` Write an octal long integer into a buffer.
`static int` | `formatNameBytes(String name, byte[] buf, int offset, int length)` Copy a name (StringBuffer) into a buffer.
`static int` | `formatOctalBytes(long value, byte[] buf, int offset, int length)` Write an octal integer into a buffer.
`static void` | `formatUnsignedOctalString(long value, byte[] buffer, int offset, int length)` Fill buffer with unsigned octal number, padded with leading zeroes.
`static boolean` | `parseBoolean(byte[] buffer, int offset)` Parse a boolean byte from a buffer.
`static String` | `parseName(byte[] buffer, int offset, int length)` Parse an entry name from a buffer.
`static long` | `parseOctal(byte[] buffer, int offset, int length)` Parse an octal string from a buffer.

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

Method Detail

### parseOctal

    public static long parseOctal(byte[] buffer,
                                  int offset,
                                  int length)

  Parse an octal string from a buffer. Leading spaces are ignored. The buffer must contain a trailing space or NUL, and may contain an additional trailing space or NUL. The input buffer is allowed to contain all NULs, in which case the method returns 0L (this allows for missing fields).

  Parameters:
    `buffer` - The buffer from which to parse.
    `offset` - The offset into the buffer from which to parse.
    `length` - The maximum number of bytes to parse - must be at least 2 bytes.
  Returns:
    The long value of the octal string.
  Throws:
    `IllegalArgumentException` - if the trailing space/NUL is missing or if a invalid byte is detected.

### parseBoolean

    public static boolean parseBoolean(byte[] buffer,
                                       int offset)

  Parse a boolean byte from a buffer. Leading spaces and NUL are ignored. The buffer may contain trailing spaces or NULs.

  Parameters:
    `buffer` - The buffer from which to parse.
    `offset` - The offset into the buffer from which to parse.
  Returns:
    The boolean value of the bytes.
  Throws:
    `IllegalArgumentException` - if an invalid byte is detected.

### parseName

    public static String parseName(byte[] buffer,
                                   int offset,
                                   int length)

  Parse an entry name from a buffer. Parsing stops when a NUL is found or the buffer length is reached.

  Parameters:
    `buffer` - The buffer from which to parse.
    `offset` - The offset into the buffer from which to parse.
    `length` - The maximum number of bytes to parse.
  Returns:
    The entry name.

### formatNameBytes

    public static int formatNameBytes(String name,
                                      byte[] buf,
                                      int offset,
                                      int length)

  Copy a name (StringBuffer) into a buffer. Copies characters from the name into the buffer starting at the specified offset. If the buffer is longer than the name, the buffer is filled with trailing NULs. If the name is longer than the buffer, the output is truncated.

  Parameters:
    `name` - The header name from which to copy the characters.
    `buf` - The buffer where the name is to be stored.
    `offset` - The starting offset into the buffer
    `length` - The maximum number of header bytes to copy.
  Returns:
    The updated offset, i.e. offset + length

### formatUnsignedOctalString

    public static void formatUnsignedOctalString(long value,
                                                 byte[] buffer,
                                                 int offset,
                                                 int length)

  Fill buffer with unsigned octal number, padded with leading zeroes.

  Parameters:
    `value` - number to convert to octal - treated as unsigned
    `buffer` - destination buffer
    `offset` - starting offset in buffer
    `length` - length of buffer to fill
  Throws:
    `IllegalArgumentException` - if the value will not fit in the buffer

### formatOctalBytes

    public static int formatOctalBytes(long value,
                                       byte[] buf,
                                       int offset,
                                       int length)

  Write an octal integer into a buffer. Uses `formatUnsignedOctalString(long, byte[], int, int)` to format the value as an octal string with leading zeros. The converted number is followed by space and NUL

  Parameters:
    `value` - The value to write
    `buf` - The buffer to receive the output
    `offset` - The starting offset into the buffer
    `length` - The size of the output buffer
  Returns:
    The updated offset, i.e offset+length
  Throws:
    `IllegalArgumentException` - if the value (and trailer) will not fit in the buffer

### formatLongOctalBytes

    public static int formatLongOctalBytes(long value,
                                           byte[] buf,
                                           int offset,
                                           int length)

  Write an octal long integer into a buffer. Uses `formatUnsignedOctalString(long, byte[], int, int)` to format the value as an octal string with leading zeros. The converted number is followed by a space.

  Parameters:
    `value` - The value to write as octal
    `buf` - The destinationbuffer.
    `offset` - The starting offset into the buffer.
    `length` - The length of the buffer
  Returns:
    The updated offset
  Throws:
    `IllegalArgumentException` - if the value (and trailer) will not fit in the buffer

### formatCheckSumOctalBytes

    public static int formatCheckSumOctalBytes(long value,
                                               byte[] buf,
                                               int offset,
                                               int length)

  Writes an octal value into a buffer. Uses `formatUnsignedOctalString(long, byte[], int, int)` to format the value as an octal string with leading zeros. The converted number is followed by NUL and then space.

  Parameters:
    `value` - The value to convert
    `buf` - The destination buffer
    `offset` - The starting offset into the buffer.
    `length` - The size of the buffer.
  Returns:
    The updated value of offset, i.e. offset+length
  Throws:
    `IllegalArgumentException` - if the value (and trailer) will not fit in the buffer

### computeCheckSum

    public static long computeCheckSum(byte[] buf)

  Compute the checksum of a tar entry header.

  Parameters:
    `buf` - The tar entry's header buffer.
  Returns:
    The computed checksum.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2011 The Apache Software Foundation. All Rights Reserved.