Base64Variant (jackson-core 2.7.4)

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

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`_reportBase64EOF()`
`protected void`	`_reportInvalidBase64(char ch, int bindex, String msg)`
`byte[]`	`decode(String input)` Convenience method for decoding contents of a Base64-encoded String, using this variant's settings.
`void`	`decode(String str, ByteArrayBuilder builder)` Convenience method for decoding contents of a Base64-encoded String, using this variant's settings and appending decoded binary data using provided `ByteArrayBuilder`.
`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)`
`boolean`	`equals(Object o)`
`int`	`getMaxLineLength()`
`String`	`getName()`
`byte`	`getPaddingByte()`
`char`	`getPaddingChar()`
`int`	`hashCode()`
`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, finalize, getClass, 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
  - decode
```
public byte[] decode(String input)
              throws IllegalArgumentException
```
    Convenience method for decoding contents of a Base64-encoded String, using this variant's settings.
    
    Parameters:
    
    input -
    
    Throws:
    
    IllegalArgumentException - if input is not valid base64 encoded data
    
    Since:
    
    2.2.3
  - decode
```
public void decode(String str,
                   ByteArrayBuilder builder)
            throws IllegalArgumentException
```
    Convenience method for decoding contents of a Base64-encoded String, using this variant's settings and appending decoded binary data using provided ByteArrayBuilder.
    NOTE: builder will NOT be reset before decoding (nor cleared afterwards); assumption is that caller will ensure it is given in proper state, and used as appropriate afterwards.
    
    Throws:
    
    IllegalArgumentException - if input is not valid base64 encoded data
    
    Since:
    
    2.2.3
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - _reportInvalidBase64
```
protected void _reportInvalidBase64(char ch,
                                    int bindex,
                                    String msg)
                             throws IllegalArgumentException
```
    Parameters:
    
    bindex - Relative index within base64 character unit; between 0 and 3 (as unit has exactly 4 characters)
    
    Throws:
    
    IllegalArgumentException
  - _reportBase64EOF
```
protected void _reportBase64EOF()
                         throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException

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

decode

decode

toString

equals

hashCode

_reportInvalidBase64

_reportBase64EOF