Base64Variant (jackson-core 2.1.2)

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

Fields
Modifier and Type	Field and Description
`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

Constructors
Constructor and Description
`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

Methods
Modifier and Type	Method and Description
`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

Class Base64Variant

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BASE64_VALUE_INVALID

BASE64_VALUE_PADDING

_name

_usesPadding

_paddingChar

_maxLineLength

Constructor Detail

Base64Variant

Base64Variant

Base64Variant

Method Detail

readResolve

getName

usesPadding

usesPaddingChar

usesPaddingChar

getPaddingChar

getPaddingByte

getMaxLineLength

decodeBase64Char

decodeBase64Char

decodeBase64Byte

encodeBase64BitsAsChar

encodeBase64Chunk

encodeBase64Chunk

encodeBase64Partial

encodeBase64Partial

encodeBase64BitsAsByte

encodeBase64Chunk

encodeBase64Partial

encode

encode

toString