com.hazelcast.com.fasterxml.jackson.core

## Class Base64Variant

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

- All Implemented Interfaces:
    Serializable

      public final class Base64Variant
      extends Object
      implements Serializable

  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
    --- | ---
    `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

  - ### 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.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`

Copyright © 2020. All rights reserved.