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

## com.fasterxml.jackson.core
Class Base64Variant

    java.lang.Object
      com.fasterxml.jackson.core.Base64Variant

All Implemented Interfaces:
  Serializable

    public final class Base64Variant

extends Object
implements Serializable

Abstract base class used to define specific details of which variant of Base64 encoding/decoding is to be used. Although there is somewhat standard basic version (so-called "MIME Base64"), other variants exists, see Base64 Wikipedia entry for details.

Author:
  Tatu Saloranta
See Also:
  Serialized Form

Field Summary
`protected int` | `_maxLineLength` Maximum number of encoded base64 characters to output during encoding before adding a linefeed, if line length is to be limited (`Integer.MAX_VALUE` if not limited).
`protected String` | `_name` Symbolic name of variant; used for diagnostics/debugging.
`protected char` | `_paddingChar` Characted used for padding, if any (`PADDING_CHAR_NONE` if not).
`protected boolean` | `_usesPadding` Whether this variant uses padding or not.
`static int` | `BASE64_VALUE_INVALID` Marker used to denote ascii characters that do not correspond to a 6-bit value (in this variant), and is not used as a padding character.
`static int` | `BASE64_VALUE_PADDING` Marker used to denote ascii character (in decoding table) that is the padding character using this variant (if any).

Constructor Summary
`Base64Variant(Base64Variant base, String name, boolean usesPadding, char paddingChar, int maxLineLength)` "Copy constructor" that can be used when the base alphabet is identical to one used by another variant, but other details (padding, maximum line length) differ
`Base64Variant(Base64Variant base, String name, int maxLineLength)` "Copy constructor" that can be used when the base alphabet is identical to one used by another variant except for the maximum line length (and obviously, name).
`Base64Variant(String name, String base64Alphabet, boolean usesPadding, char paddingChar, int maxLineLength)`

Method Summary
`int` | `decodeBase64Byte(byte b)`
`int` | `decodeBase64Char(char c)`
`int` | `decodeBase64Char(int ch)`
`String` | `encode(byte[] input)` Convenience method for converting given byte array as base64 encoded String using this variant's settings.
`String` | `encode(byte[] input, boolean addQuotes)` Convenience method for converting given byte array as base64 encoded String using this variant's settings, optionally enclosed in double-quotes.
`byte` | `encodeBase64BitsAsByte(int value)`
`char` | `encodeBase64BitsAsChar(int value)`
`int` | `encodeBase64Chunk(int b24, byte[] buffer, int ptr)` Method that encodes given right-aligned (LSB) 24-bit value into 4 base64 bytes (ascii), stored in given result buffer.
`int` | `encodeBase64Chunk(int b24, char[] buffer, int ptr)` Method that encodes given right-aligned (LSB) 24-bit value into 4 base64 characters, stored in given result buffer.
`void` | `encodeBase64Chunk(StringBuilder sb, int b24)`
`int` | `encodeBase64Partial(int bits, int outputBytes, byte[] buffer, int outPtr)` Method that outputs partial chunk (which only encodes one or two bytes of data).
`int` | `encodeBase64Partial(int bits, int outputBytes, char[] buffer, int outPtr)` Method that outputs partial chunk (which only encodes one or two bytes of data).
`void` | `encodeBase64Partial(StringBuilder sb, int bits, int outputBytes)`
`int` | `getMaxLineLength()`
`String` | `getName()`
`byte` | `getPaddingByte()`
`char` | `getPaddingChar()`
`protected Object` | `readResolve()` Method used to "demote" deserialized instances back to canonical ones
`String` | `toString()`
`boolean` | `usesPadding()`
`boolean` | `usesPaddingChar(char c)`
`boolean` | `usesPaddingChar(int ch)`

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

Field Detail

### BASE64_VALUE_INVALID

    public static final int BASE64_VALUE_INVALID

  Marker used to denote ascii characters that do not correspond to a 6-bit value (in this variant), and is not used as a padding character.

  See Also:
    Constant Field Values

### BASE64_VALUE_PADDING

    public static final int BASE64_VALUE_PADDING

  Marker used to denote ascii character (in decoding table) that is the padding character using this variant (if any).

  See Also:
    Constant Field Values

### _name

    protected final String _name

  Symbolic name of variant; used for diagnostics/debugging.

  Note that this is the only non-transient field; used when reading back from serialized state

### _usesPadding

    protected final transient boolean _usesPadding

  Whether this variant uses padding or not.

### _paddingChar

    protected final transient char _paddingChar

  Characted used for padding, if any (`PADDING_CHAR_NONE` if not).

### _maxLineLength

    protected final transient int _maxLineLength

  Maximum number of encoded base64 characters to output during encoding before adding a linefeed, if line length is to be limited (`Integer.MAX_VALUE` if not limited).

  Note: for some output modes (when writing attributes) linefeeds may need to be avoided, and this value ignored.

Constructor Detail

### Base64Variant

    public Base64Variant(String name,
                         String base64Alphabet,
                         boolean usesPadding,
                         char paddingChar,
                         int maxLineLength)

### Base64Variant

    public Base64Variant(Base64Variant base,
                         String name,
                         int maxLineLength)

  "Copy constructor" that can be used when the base alphabet is identical to one used by another variant except for the maximum line length (and obviously, name).

### Base64Variant

    public Base64Variant(Base64Variant base,
                         String name,
                         boolean usesPadding,
                         char paddingChar,
                         int maxLineLength)

  "Copy constructor" that can be used when the base alphabet is identical to one used by another variant, but other details (padding, maximum line length) differ

Method Detail

### readResolve

    protected Object readResolve()

  Method used to "demote" deserialized instances back to canonical ones

### getName

    public String getName()

### usesPadding

    public boolean usesPadding()

### usesPaddingChar

    public boolean usesPaddingChar(char c)

### usesPaddingChar

    public boolean usesPaddingChar(int ch)

### getPaddingChar

    public char getPaddingChar()

### getPaddingByte

    public byte getPaddingByte()

### getMaxLineLength

    public int getMaxLineLength()

### decodeBase64Char

    public int decodeBase64Char(char c)

  Returns:
    6-bit decoded value, if valid character;

### decodeBase64Char

    public int decodeBase64Char(int ch)

### decodeBase64Byte

    public int decodeBase64Byte(byte b)

### encodeBase64BitsAsChar

    public char encodeBase64BitsAsChar(int value)

### encodeBase64Chunk

    public int encodeBase64Chunk(int b24,
                                 char[] buffer,
                                 int ptr)

  Method that encodes given right-aligned (LSB) 24-bit value into 4 base64 characters, stored in given result buffer.

### encodeBase64Chunk

    public void encodeBase64Chunk(StringBuilder sb,
                                  int b24)

### encodeBase64Partial

    public int encodeBase64Partial(int bits,
                                   int outputBytes,
                                   char[] buffer,
                                   int outPtr)

  Method that outputs partial chunk (which only encodes one or two bytes of data). Data given is still aligned same as if it as full data; that is, missing data is at the "right end" (LSB) of int.

  Parameters:
    `outputBytes` - Number of encoded bytes included (either 1 or 2)

### encodeBase64Partial

    public void encodeBase64Partial(StringBuilder sb,
                                    int bits,
                                    int outputBytes)

### encodeBase64BitsAsByte

    public byte encodeBase64BitsAsByte(int value)

### encodeBase64Chunk

    public int encodeBase64Chunk(int b24,
                                 byte[] buffer,
                                 int ptr)

  Method that encodes given right-aligned (LSB) 24-bit value into 4 base64 bytes (ascii), stored in given result buffer.

### encodeBase64Partial

    public int encodeBase64Partial(int bits,
                                   int outputBytes,
                                   byte[] buffer,
                                   int outPtr)

  Method that outputs partial chunk (which only encodes one or two bytes of data). Data given is still aligned same as if it as full data; that is, missing data is at the "right end" (LSB) of int.

  Parameters:
    `outputBytes` - Number of encoded bytes included (either 1 or 2)

### encode

    public String encode(byte[] input)

  Convenience method for converting given byte array as base64 encoded String using this variant's settings. Resulting value is "raw", that is, not enclosed in double-quotes.

  Parameters:
    `input` - Byte array to encode

### encode

    public String encode(byte[] input,
                         boolean addQuotes)

  Convenience method for converting given byte array as base64 encoded String using this variant's settings, optionally enclosed in double-quotes.

  Parameters:
    `input` - Byte array to encode
    `addQuotes` - Whether to surround resulting value in double quotes or not

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

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 © 2012 FasterXML. All Rights Reserved.