Java 类com.fasterxml.jackson.core.Base64Variant 实例源码

public byte[] getBinaryValue(Base64Variant paramBase64Variant)
{
  JsonNode localJsonNode = currentNode();
  if (localJsonNode != null)
  {
    byte[] arrayOfByte = localJsonNode.binaryValue();
    if (arrayOfByte != null)
      return arrayOfByte;
    if (localJsonNode.isPojo())
    {
      Object localObject = ((POJONode)localJsonNode).getPojo();
      if ((localObject instanceof byte[]))
        return (byte[])localObject;
    }
  }
  return null;
}

@Deprecated
protected void _reportInvalidBase64(Base64Variant paramBase64Variant, char paramChar, int paramInt, String paramString)
{
  String str;
  if (paramChar <= ' ')
    str = "Illegal white space character (code 0x" + Integer.toHexString(paramChar) + ") as character #" + (paramInt + 1) + " of 4-char base64 unit: can only used between units";
  else if (paramBase64Variant.usesPaddingChar(paramChar))
    str = "Unexpected padding character ('" + paramBase64Variant.getPaddingChar() + "') as character #" + (paramInt + 1) + " of 4-char base64 unit: padding only legal as 3rd or 4th character";
  else if ((!Character.isDefined(paramChar)) || (Character.isISOControl(paramChar)))
    str = "Illegal character (code 0x" + Integer.toHexString(paramChar) + ") in base64 content";
  else
    str = "Illegal character '" + paramChar + "' (code 0x" + Integer.toHexString(paramChar) + ") in base64 content";
  if (paramString != null)
    str = str + ": " + paramString;
  throw _constructError(str);
}

public final byte[] getBinaryValue(Base64Variant paramBase64Variant)
{
  if ((this._currToken != JsonToken.VALUE_STRING) && ((this._currToken != JsonToken.VALUE_EMBEDDED_OBJECT) || (this._binaryValue == null)))
    _reportError("Current token (" + this._currToken + ") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
  if (this._tokenIncomplete)
  {
    try
    {
      this._binaryValue = _decodeBase64(paramBase64Variant);
    }
    catch (IllegalArgumentException localIllegalArgumentException)
    {
      throw _constructError("Failed to decode VALUE_STRING as base64 (" + paramBase64Variant + "): " + localIllegalArgumentException.getMessage());
    }
    this._tokenIncomplete = false;
  }
  else if (this._binaryValue == null)
  {
    ByteArrayBuilder localByteArrayBuilder = _getByteArrayBuilder();
    _decodeBase64(getText(), localByteArrayBuilder, paramBase64Variant);
    this._binaryValue = localByteArrayBuilder.toByteArray();
  }
  return this._binaryValue;
}

public final int readBinaryValue(Base64Variant paramBase64Variant, OutputStream paramOutputStream)
{
  if ((!this._tokenIncomplete) || (this._currToken != JsonToken.VALUE_STRING))
  {
    byte[] arrayOfByte1 = getBinaryValue(paramBase64Variant);
    paramOutputStream.write(arrayOfByte1);
    return arrayOfByte1.length;
  }
  byte[] arrayOfByte2 = this._ioContext.allocBase64Buffer();
  try
  {
    int i = _readBinary(paramBase64Variant, paramOutputStream, arrayOfByte2);
    return i;
  }
  finally
  {
    this._ioContext.releaseBase64Buffer(arrayOfByte2);
  }
}

public final void writeBinary(Base64Variant paramBase64Variant, byte[] paramArrayOfByte, int paramInt1, int paramInt2)
{
  _verifyValueWrite("write binary value");
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  char[] arrayOfChar1 = this._outputBuffer;
  int i = this._outputTail;
  this._outputTail = (i + 1);
  arrayOfChar1[i] = '"';
  _writeBinary(paramBase64Variant, paramArrayOfByte, paramInt1, paramInt1 + paramInt2);
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  char[] arrayOfChar2 = this._outputBuffer;
  int j = this._outputTail;
  this._outputTail = (j + 1);
  arrayOfChar2[j] = '"';
}

public void writeBinary(Base64Variant paramBase64Variant, byte[] paramArrayOfByte, int paramInt1, int paramInt2)
{
  _verifyValueWrite("write binary value");
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  byte[] arrayOfByte1 = this._outputBuffer;
  int i = this._outputTail;
  this._outputTail = (i + 1);
  arrayOfByte1[i] = 34;
  _writeBinary(paramBase64Variant, paramArrayOfByte, paramInt1, paramInt1 + paramInt2);
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  byte[] arrayOfByte2 = this._outputBuffer;
  int j = this._outputTail;
  this._outputTail = (j + 1);
  arrayOfByte2[j] = 34;
}

public final byte[] getBinaryValue(Base64Variant paramBase64Variant)
{
  if ((this._currToken != JsonToken.VALUE_STRING) && ((this._currToken != JsonToken.VALUE_EMBEDDED_OBJECT) || (this._binaryValue == null)))
    _reportError("Current token (" + this._currToken + ") not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary");
  if (this._tokenIncomplete)
  {
    try
    {
      this._binaryValue = _decodeBase64(paramBase64Variant);
    }
    catch (IllegalArgumentException localIllegalArgumentException)
    {
      throw _constructError("Failed to decode VALUE_STRING as base64 (" + paramBase64Variant + "): " + localIllegalArgumentException.getMessage());
    }
    this._tokenIncomplete = false;
  }
  else if (this._binaryValue == null)
  {
    ByteArrayBuilder localByteArrayBuilder = _getByteArrayBuilder();
    _decodeBase64(getText(), localByteArrayBuilder, paramBase64Variant);
    this._binaryValue = localByteArrayBuilder.toByteArray();
  }
  return this._binaryValue;
}

public final int readBinaryValue(Base64Variant paramBase64Variant, OutputStream paramOutputStream)
{
  if ((!this._tokenIncomplete) || (this._currToken != JsonToken.VALUE_STRING))
  {
    byte[] arrayOfByte1 = getBinaryValue(paramBase64Variant);
    paramOutputStream.write(arrayOfByte1);
    return arrayOfByte1.length;
  }
  byte[] arrayOfByte2 = this._ioContext.allocBase64Buffer();
  try
  {
    int i = _readBinary(paramBase64Variant, paramOutputStream, arrayOfByte2);
    return i;
  }
  finally
  {
    this._ioContext.releaseBase64Buffer(arrayOfByte2);
  }
}

public BaseSettings(ClassIntrospector ci, AnnotationIntrospector ai,
        VisibilityChecker<?> vc, PropertyNamingStrategy pns, TypeFactory tf,
        TypeResolverBuilder<?> typer, DateFormat dateFormat, HandlerInstantiator hi,
        Locale locale, TimeZone tz, Base64Variant defaultBase64)
{
    _classIntrospector = ci;
    _annotationIntrospector = ai;
    _visibilityChecker = vc;
    _propertyNamingStrategy = pns;
    _typeFactory = tf;
    _typeResolverBuilder = typer;
    _dateFormat = dateFormat;
    _handlerInstantiator = hi;
    _locale = locale;
    _timeZone = tz;
    _defaultBase64 = defaultBase64;
}

public void testBase64Variant() throws Exception
{
    Base64Variant orig = Base64Variants.PEM;
    byte[] stuff = jdkSerialize(orig);
    Base64Variant back = jdkDeserialize(stuff);
    assertSame(orig, back);
}

@Override
public void writeBinary(final Base64Variant bv, final byte[] data, final int offset, final int len)
        throws IOException {
    try {
        builder.add(attribute, data);
        attribute = null;
    } catch (final VPackBuilderException e) {
        throw new IOException(e);
    }
}

@Override
public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException {
    if (offset == 0 && len == data.length) {
        writeString(b64variant.encode(data));
    } else {
        byte[] range = Arrays.copyOfRange(data, offset, offset + len);
        writeString(b64variant.encode(range));
    }
}

@Override
public void writeBinary(Base64Variant bv,
    byte[] data, int offset, int len) throws IOException {
  ByteBuffer buff = ByteBuffer.wrap(data, offset, len);
  if (inMap()) {
    b.put(currFieldName, buff);
  } else {
    b.add(buff);
  }
}

@Override
public byte[] getBinaryValue(Base64Variant bv) throws IOException {
  ByteBuffer buf = r.getBinary();
  byte[] result = new byte[buf.remaining()];
  buf.get(result);
  return result;
}

@Override
public byte[] getBinaryValue(Base64Variant b64variant) throws IOException, JsonParseException {
    if (currentToken != null) {
        String text = currentToken.getText();
        return Base64.getDecoder().decode(text); // PENDING: howto deal with the variant?
    } else {
        return p.getBinaryValue(b64variant);
    }
}

@Override
public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) throws IOException {
    if (offset == 0 && len == data.length) {
        writeString(b64variant.encode(data));
    } else {
        byte[] range = Arrays.copyOfRange(data, offset, offset + len);
        writeString(b64variant.encode(range));
    }
}

public BaseSettings(ClassIntrospector paramClassIntrospector, AnnotationIntrospector paramAnnotationIntrospector, VisibilityChecker<?> paramVisibilityChecker, PropertyNamingStrategy paramPropertyNamingStrategy, TypeFactory paramTypeFactory, TypeResolverBuilder<?> paramTypeResolverBuilder, DateFormat paramDateFormat, HandlerInstantiator paramHandlerInstantiator, Locale paramLocale, TimeZone paramTimeZone, Base64Variant paramBase64Variant)
{
  this._classIntrospector = paramClassIntrospector;
  this._annotationIntrospector = paramAnnotationIntrospector;
  this._visibilityChecker = paramVisibilityChecker;
  this._propertyNamingStrategy = paramPropertyNamingStrategy;
  this._typeFactory = paramTypeFactory;
  this._typeResolverBuilder = paramTypeResolverBuilder;
  this._dateFormat = paramDateFormat;
  this._handlerInstantiator = paramHandlerInstantiator;
  this._locale = paramLocale;
  this._timeZone = paramTimeZone;
  this._defaultBase64 = paramBase64Variant;
}

public final BaseSettings with(TimeZone paramTimeZone)
{
  if (paramTimeZone == null)
    throw new IllegalArgumentException();
  DateFormat localDateFormat1 = this._dateFormat;
  Object localObject;
  if ((localDateFormat1 instanceof StdDateFormat))
  {
    localObject = ((StdDateFormat)localDateFormat1).withTimeZone(paramTimeZone);
  }
  else
  {
    DateFormat localDateFormat2 = (DateFormat)localDateFormat1.clone();
    localObject = localDateFormat2;
    localDateFormat2.setTimeZone(paramTimeZone);
  }
  ClassIntrospector localClassIntrospector = this._classIntrospector;
  AnnotationIntrospector localAnnotationIntrospector = this._annotationIntrospector;
  VisibilityChecker localVisibilityChecker = this._visibilityChecker;
  PropertyNamingStrategy localPropertyNamingStrategy = this._propertyNamingStrategy;
  TypeFactory localTypeFactory = this._typeFactory;
  TypeResolverBuilder localTypeResolverBuilder = this._typeResolverBuilder;
  HandlerInstantiator localHandlerInstantiator = this._handlerInstantiator;
  Locale localLocale = this._locale;
  Base64Variant localBase64Variant = this._defaultBase64;
  return new BaseSettings(localClassIntrospector, localAnnotationIntrospector, localVisibilityChecker, localPropertyNamingStrategy, localTypeFactory, localTypeResolverBuilder, (DateFormat)localObject, localHandlerInstantiator, localLocale, paramTimeZone, localBase64Variant);
}

public final byte[] getBinaryValue(Base64Variant paramBase64Variant)
{
  if (this._currToken == JsonToken.VALUE_EMBEDDED_OBJECT)
  {
    Object localObject2 = _currentObject();
    if ((localObject2 instanceof byte[]))
      return (byte[])localObject2;
  }
  if (this._currToken != JsonToken.VALUE_STRING)
    throw _constructError("Current token (" + this._currToken + ") not VALUE_STRING (or VALUE_EMBEDDED_OBJECT with byte[]), can not access as binary");
  String str = getText();
  if (str == null)
    return null;
  ByteArrayBuilder localByteArrayBuilder1 = this._byteBuilder;
  Object localObject1 = localByteArrayBuilder1;
  if (localByteArrayBuilder1 == null)
  {
    ByteArrayBuilder localByteArrayBuilder2 = new ByteArrayBuilder(100);
    localObject1 = localByteArrayBuilder2;
    this._byteBuilder = localByteArrayBuilder2;
  }
  else
  {
    this._byteBuilder.reset();
  }
  _decodeBase64(str, (ByteArrayBuilder)localObject1, paramBase64Variant);
  return ((ByteArrayBuilder)localObject1).toByteArray();
}

public final int readBinaryValue(Base64Variant paramBase64Variant, OutputStream paramOutputStream)
{
  byte[] arrayOfByte = getBinaryValue(paramBase64Variant);
  if (arrayOfByte != null)
  {
    paramOutputStream.write(arrayOfByte, 0, arrayOfByte.length);
    return arrayOfByte.length;
  }
  return 0;
}

public ObjectWriter with(Base64Variant paramBase64Variant)
{
  SerializationConfig localSerializationConfig = this._config.with(paramBase64Variant);
  if (localSerializationConfig == this._config)
    return this;
  return new ObjectWriter(this, localSerializationConfig);
}

public int readBinaryValue(Base64Variant paramBase64Variant, OutputStream paramOutputStream)
{
  byte[] arrayOfByte = getBinaryValue(paramBase64Variant);
  if (arrayOfByte != null)
  {
    paramOutputStream.write(arrayOfByte, 0, arrayOfByte.length);
    return arrayOfByte.length;
  }
  return 0;
}

protected final void _reportInvalidBase64(Base64Variant paramBase64Variant, char paramChar, int paramInt, String paramString)
{
  String str;
  if (paramChar <= ' ')
    str = "Illegal white space character (code 0x" + Integer.toHexString(paramChar) + ") as character #" + (paramInt + 1) + " of 4-char base64 unit: can only used between units";
  else if (paramBase64Variant.usesPaddingChar(paramChar))
    str = "Unexpected padding character ('" + paramBase64Variant.getPaddingChar() + "') as character #" + (paramInt + 1) + " of 4-char base64 unit: padding only legal as 3rd or 4th character";
  else if ((!Character.isDefined(paramChar)) || (Character.isISOControl(paramChar)))
    str = "Illegal character (code 0x" + Integer.toHexString(paramChar) + ") in base64 content";
  else
    str = "Illegal character '" + paramChar + "' (code 0x" + Integer.toHexString(paramChar) + ") in base64 content";
  if (paramString != null)
    str = str + ": " + paramString;
  throw new JsonParseException(str, JsonLocation.NA);
}

public void _decodeBase64(String paramString, ByteArrayBuilder paramByteArrayBuilder, Base64Variant paramBase64Variant)
{
  try
  {
    paramBase64Variant.decode(paramString, paramByteArrayBuilder);
    return;
  }
  catch (IllegalArgumentException localIllegalArgumentException)
  {
    _reportError(localIllegalArgumentException.getMessage());
  }
}

public final int writeBinary(Base64Variant paramBase64Variant, InputStream paramInputStream, int paramInt)
{
  _verifyValueWrite("write binary value");
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  char[] arrayOfChar1 = this._outputBuffer;
  int i = this._outputTail;
  this._outputTail = (i + 1);
  arrayOfChar1[i] = '"';
  byte[] arrayOfByte = this._ioContext.allocBase64Buffer();
  if (paramInt < 0);
  int j;
  try
  {
    j = _writeBinary(paramBase64Variant, paramInputStream, arrayOfByte);
    break label132;
    int m = _writeBinary(paramBase64Variant, paramInputStream, arrayOfByte, paramInt);
    if (m > 0)
      _reportError("Too few bytes available: missing " + m + " bytes (out of " + paramInt + ")");
    j = paramInt;
  }
  finally
  {
    label132: this._ioContext.releaseBase64Buffer(arrayOfByte);
  }
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  char[] arrayOfChar2 = this._outputBuffer;
  int k = this._outputTail;
  this._outputTail = (k + 1);
  arrayOfChar2[k] = '"';
  return j;
}

public int writeBinary(Base64Variant paramBase64Variant, InputStream paramInputStream, int paramInt)
{
  _verifyValueWrite("write binary value");
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  byte[] arrayOfByte1 = this._outputBuffer;
  int i = this._outputTail;
  this._outputTail = (i + 1);
  arrayOfByte1[i] = 34;
  byte[] arrayOfByte2 = this._ioContext.allocBase64Buffer();
  if (paramInt < 0);
  int j;
  try
  {
    j = _writeBinary(paramBase64Variant, paramInputStream, arrayOfByte2);
    break label132;
    int m = _writeBinary(paramBase64Variant, paramInputStream, arrayOfByte2, paramInt);
    if (m > 0)
      _reportError("Too few bytes available: missing " + m + " bytes (out of " + paramInt + ")");
    j = paramInt;
  }
  finally
  {
    label132: this._ioContext.releaseBase64Buffer(arrayOfByte2);
  }
  if (this._outputTail >= this._outputEnd)
    _flushBuffer();
  byte[] arrayOfByte3 = this._outputBuffer;
  int k = this._outputTail;
  this._outputTail = (k + 1);
  arrayOfByte3[k] = 34;
  return j;
}

@Override
public byte[] getBinaryValue(Base64Variant b64variant) throws IOException, JsonParseException {
    Object obj = getEmbeddedObject();
    if (obj instanceof byte[]) {
        return (byte[])obj;
    } else {
        return getText().getBytes();
    }
}

/**
 * @since 2.1
 */
public BaseSettings with(Base64Variant base64) {
    if (base64 == _defaultBase64) {
        return this;
    }
    return new BaseSettings(_classIntrospector, _annotationIntrospector,
            _visibilityChecker, _propertyNamingStrategy, _typeFactory,
            _typeResolverBuilder, _dateFormat, _handlerInstantiator, _locale,
            _timeZone, base64);
}

@Override
public byte[] getBinaryValue(Base64Variant b64variant)
    throws IOException, JsonParseException
{
    // otherwise return null to mark we have no binary content
    return null;
}

@Override
public int readBinaryValue(Base64Variant b64variant, OutputStream out)
        throws IOException, JsonParseException
{
    byte[] data = getBinaryValue(b64variant);
    if (data != null) {
        out.write(data, 0, data.length);
        return data.length;
    }
    return 0;
}

@Override
public byte[] getBinaryValue(final Base64Variant b64variant) throws IOException {
    return null;
}

@Override
public byte[] getBinaryValue(Base64Variant bv) throws IOException {
    throw new UnsupportedOperationException();
}

@Override
public byte[] getBinaryValue(Base64Variant bv) throws IOException {
    throw new UnsupportedOperationException();
}

@Override
public int writeBinary(Base64Variant bv,
    InputStream data, int dataLength) throws IOException {
  notImplemented();
  return 0;
}

public final Base64Variant getBase64Variant()
{
  return this._defaultBase64;
}

public final BaseSettings with(Base64Variant paramBase64Variant)
{
  if (paramBase64Variant == this._defaultBase64)
    return this;
  return new BaseSettings(this._classIntrospector, this._annotationIntrospector, this._visibilityChecker, this._propertyNamingStrategy, this._typeFactory, this._typeResolverBuilder, this._dateFormat, this._handlerInstantiator, this._locale, this._timeZone, paramBase64Variant);
}

public Base64Variant getBase64Variant()
{
  return this._base.getBase64Variant();
}

public ObjectReader with(Base64Variant paramBase64Variant)
{
  return _with(this._config.with(paramBase64Variant));
}

public final SerializationConfig with(Base64Variant paramBase64Variant)
{
  return _withBase(this._base.with(paramBase64Variant));
}

public final DeserializationConfig with(Base64Variant paramBase64Variant)
{
  return _withBase(this._base.with(paramBase64Variant));
}