Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Jackson JSON-processor.
   *
   * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
   *
   * Licensed under the License specified in file LICENSE, included with
   * the source code and binary code bundles.
   * You may not use this file except in compliance with the License.
   *
   * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.fasterxml.jackson.core;

Container for commonly used Base64 variants:

Author(s):
Tatu Saloranta
 
 public final class Base64Variants
 {
     final static String STD_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    
This variant is what most people would think of "the standard" Base64 encoding.

See wikipedia Base64 entry for details.

Note that although this can be thought of as the standard variant, it is not the default for Jackson: no-linefeeds alternative is because of JSON requirement of escaping all linefeeds.

 
     public final static Base64Variant MIME;
     static {
          = new Base64Variant("MIME"true'=', 76);
     }

    
Slightly non-standard modification of MIME which does not use linefeeds (max line length set to infinite). Useful when linefeeds wouldn't work well (possibly in attributes), or for minor space savings (save 1 linefeed per 76 data chars, ie. ~1.4% savings).
 
     public final static Base64Variant MIME_NO_LINEFEEDS;
     static {
          = new Base64Variant("MIME-NO-LINEFEEDS".);
     }

    
This variant is the one that predates MIME: it is otherwise identical, except that it mandates shorter line length.
 
     public final static Base64Variant PEM = new Base64Variant("PEM"true'=', 64);

    
This non-standard variant is usually used when encoded data needs to be passed via URLs (such as part of GET request). It differs from the base MIME variant in multiple ways. First, no padding is used: this also means that it generally can not be written in multiple separate but adjacent chunks (which would not be the usual use case in any case). Also, no linefeeds are used (max line length set to infinite). And finally, two characters (plus and slash) that would need quoting in URLs are replaced with more optimal alternatives (hyphen and underscore, respectively).
 
     public final static Base64Variant MODIFIED_FOR_URL;
     static {
         StringBuffer sb = new StringBuffer();
         // Replace plus with hyphen, slash with underscore (and no padding)
         sb.setCharAt(sb.indexOf("+"), '-');
         sb.setCharAt(sb.indexOf("/"), '_');
         /* And finally, let's not split lines either, wouldn't work too
          * well with URLs
          */
          = new Base64Variant("MODIFIED-FOR-URL"sb.toString(), false..);
     }

    
Method used to get the default variant ("MIME_NO_LINEFEEDS") for cases where caller does not explicitly specify the variant. We will prefer no-linefeed version because linefeeds in JSON values must be escaped, making linefeed-containing variants sub-optimal.
 
     public static Base64Variant getDefaultVariant() {
         return ;
     }

    

Since:
2.1
 
    public static Base64Variant valueOf(String namethrows IllegalArgumentException
    {
        if (..equals(name)) {
            return ;
        }
        if (..equals(name)) {
            return ;
        }
        if (..equals(name)) {
            return ;
        }
        if (..equals(name)) {
            return ;
        }
        if (name == null) {
            name = "<null>";
        } else {
            name = "'"+name+"'";
        }
        throw new IllegalArgumentException("No Base64Variant with name "+name);
    }
New to GrepCode? Check out our FAQ X