@Override public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException if (p.hasToken(JsonToken.VALUE_STRING)) { return p.getText(); JsonToken t = p.getCurrentToken(); return ctxt.getBase64Variant().encode((byte[]) ob, false); return (String) ctxt.handleUnexpectedToken(_valueClass, p);
/** * Convenience method for decoding contents of a Base64-encoded String, * using this variant's settings. * * @param input * * @since 2.2.3 * * @throws IllegalArgumentException if input is not valid base64 encoded data */ @SuppressWarnings("resource") public byte[] decode(String input) throws IllegalArgumentException { ByteArrayBuilder b = new ByteArrayBuilder(); decode(input, b); return b.toByteArray(); }
ch = _inputData.readUnsignedByte(); } while (ch <= INT_SPACE); int bits = b64variant.decodeBase64Char(ch); if (bits < 0) { // reached the end, fair and square? if (ch == INT_QUOTE) { return builder.toByteArray(); bits = b64variant.decodeBase64Char(ch); if (bits < 0) { bits = _decodeBase64Escape(b64variant, ch, 1); bits = b64variant.decodeBase64Char(ch); builder.append(decodedData); if (b64variant.usesPadding()) { _handleBase64MissingPadding(b64variant); if (!b64variant.usesPaddingChar(ch)) { if ((ch != INT_BACKSLASH) || _decodeBase64Escape(b64variant, ch, 3) != Base64Variant.BASE64_VALUE_PADDING) { throw reportInvalidBase64Char(b64variant, ch, 3, "expected padding character '"+b64variant.getPaddingChar()+"'"); bits = b64variant.decodeBase64Char(ch); if (bits < 0) { if (bits != Base64Variant.BASE64_VALUE_PADDING) { decodedData >>= 2; builder.appendTwoBytes(decodedData); if (b64variant.usesPadding()) {
/** * Helper method that will construct a message to use in exceptions for cases where input ends * prematurely in place where padding would be expected. * * @since 2.10 */ public String missingPaddingMessage() { return String.format("Unexpected end of base64-encoded String: base64 variant '%s' expects padding (one or more '%c' characters) at the end", getName(), getPaddingChar()); }
int chunksBeforeLF = b64variant.getMaxLineLength() >> 2; _flushBuffer(); b24 |= ((int) input[inputPtr++]) & 0xFF; b24 = (b24 << 8) | (((int) input[inputPtr++]) & 0xFF); _outputTail = b64variant.encodeBase64Chunk(b24, _outputBuffer, _outputTail); if (--chunksBeforeLF <= 0) { chunksBeforeLF = b64variant.getMaxLineLength() >> 2; if (inputLeft > 0) { // yes, but do we have room for output? if (_outputTail > safeOutputEnd) { // don't really need 6 bytes but... _flushBuffer(); b24 |= (((int) input[inputPtr++]) & 0xFF) << 8; _outputTail = b64variant.encodeBase64Partial(b24, inputLeft, _outputBuffer, _outputTail);
int chunksBeforeLF = b64variant.getMaxLineLength() >> 2; b24 |= ((int) input[inputPtr++]) & 0xFF; b24 = (b24 << 8) | (((int) input[inputPtr++]) & 0xFF); _outputTail = b64variant.encodeBase64Chunk(b24, _outputBuffer, _outputTail); if (--chunksBeforeLF <= 0) { chunksBeforeLF = b64variant.getMaxLineLength() >> 2; b24 |= (((int) input[inputPtr++]) & 0xFF) << 8; _outputTail = b64variant.encodeBase64Partial(b24, inputLeft, _outputBuffer, _outputTail);
JsonToken t = jp.getCurrentToken(); if (t == JsonToken.VALUE_STRING) { char[] buffer = jp.getTextCharacters(); int offset = jp.getTextOffset(); int len = jp.getTextLength(); while ((t = jp.nextToken()) != JsonToken.END_ARRAY) { if (t != JsonToken.VALUE_STRING) { throw ctxt.mappingException(Character.TYPE); String str = jp.getText(); return Base64Variants.getDefaultVariant().encode((byte[]) ob, false).toCharArray(); throw ctxt.mappingException(_valueClass);
@Override public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException JsonToken curr = jp.getCurrentToken(); if (curr == JsonToken.VALUE_STRING) { return jp.getText(); if (curr == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { jp.nextToken(); final String parsed = _parseString(jp, ctxt); if (jp.nextToken() != JsonToken.END_ARRAY) { throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY, "Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array"); return Base64Variants.getDefaultVariant().encode((byte[]) ob, false); return text; throw ctxt.mappingException(_valueClass, curr);
JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_STRING) { char[] buffer = p.getTextCharacters(); int offset = p.getTextOffset(); int len = p.getTextLength(); str = "\0"; } else { CharSequence cs = (CharSequence) ctxt.handleUnexpectedToken(Character.TYPE, p); str = cs.toString(); ctxt.reportInputMismatch(this, "Cannot convert a JSON String of length %d into a char element of char array", str.length()); return Base64Variants.getDefaultVariant().encode((byte[]) ob, false).toCharArray(); return (char[]) ctxt.handleUnexpectedToken(_valueClass, p);
@Override public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonToken curr = jp.getCurrentToken(); // Usually should just get string value: if (curr == JsonToken.VALUE_STRING) { return jp.getText(); } // [JACKSON-330]: need to gracefully handle byte[] data, as base64 if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) { Object ob = jp.getEmbeddedObject(); if (ob == null) { return null; } if (ob instanceof byte[]) { return Base64Variants.getDefaultVariant().encode((byte[]) ob, false); } // otherwise, try conversion using toString()... return ob.toString(); } // Can deserialize any scalar value, but not markers if (curr.isScalarValue()) { return jp.getText(); } throw ctxt.mappingException(_valueClass, curr); }
protected final String _deserializeString(JsonParser p, DeserializationContext ctxt) throws IOException switch (p.currentTokenId()) { case JsonTokenId.ID_STRING: return p.getText(); case JsonTokenId.ID_NULL: return null; case JsonTokenId.ID_START_ARRAY: if (ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) { p.nextToken(); final String parsed = _deserializeString(p, ctxt); if (p.nextToken() != JsonToken.END_ARRAY) { return Base64Variants.getDefaultVariant().encode((byte[]) ob, false); return (String) ctxt.handleUnexpectedToken(String.class, p);
@Override public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { if (p.hasToken(JsonToken.VALUE_STRING)) { return p.getText(); } JsonToken t = p.currentToken(); if (t == JsonToken.START_ARRAY) { return _deserializeFromArray(p, ctxt); } if (t == JsonToken.VALUE_EMBEDDED_OBJECT) { Object ob = p.getEmbeddedObject(); if (ob == null) { return null; } if (ob instanceof byte[]) { return ctxt.getBase64Variant().encode((byte[]) ob, false); } // otherwise, try conversion using toString()... return ob.toString(); } // allow coercions, as handled by `FromXmlParser.getValueAsString()`: this includes // START_OBJECT in some cases. String text = p.getValueAsString(null); if ((text != null) || (t == JsonToken.VALUE_NULL)) { return text; } return (String) ctxt.handleUnexpectedToken(_valueClass, p); }
@Override public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { // 22-Sep-2012, tatu: For 2.1, use this new method, may force coercion: String text = jp.getValueAsString(); if (text != null) { return text; } // [JACKSON-330]: need to gracefully handle byte[] data, as base64 JsonToken curr = jp.getCurrentToken(); if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) { Object ob = jp.getEmbeddedObject(); if (ob == null) { return null; } if (ob instanceof byte[]) { return Base64Variants.getDefaultVariant().encode((byte[]) ob, false); } // otherwise, try conversion using toString()... return ob.toString(); } throw ctxt.mappingException(_valueClass, curr); }
/** * Different from other values, since contents need to be surrounded * by (double) quotes. */ @Override public String toString() { return Base64Variants.getDefaultVariant().encode(_data, true); } }
int bits = decodeBase64Char(ch); if (bits < 0) { _reportInvalidBase64(ch, 0, null); _reportBase64EOF(); bits = decodeBase64Char(ch); if (bits < 0) { _reportInvalidBase64(ch, 1, null); if (!usesPadding()) { decodedData >>= 4; builder.append(decodedData); break; _reportBase64EOF(); bits = decodeBase64Char(ch); _reportInvalidBase64(ch, 2, null); _reportBase64EOF(); if (!usesPaddingChar(ch)) { _reportInvalidBase64(ch, 3, "expected padding character '"+getPaddingChar()+"'"); if (!usesPadding()) { decodedData >>= 2; builder.appendTwoBytes(decodedData);
ch = _inputData.readUnsignedByte(); } while (ch <= INT_SPACE); int bits = b64variant.decodeBase64Char(ch); if (bits < 0) { // reached the end, fair and square? if (ch == INT_QUOTE) { bits = b64variant.decodeBase64Char(ch); if (bits < 0) { bits = _decodeBase64Escape(b64variant, ch, 1); bits = b64variant.decodeBase64Char(ch); decodedData >>= 4; buffer[outputPtr++] = (byte) decodedData; if (b64variant.usesPadding()) { _handleBase64MissingPadding(b64variant); if (!b64variant.usesPaddingChar(ch)) { if ((ch != INT_BACKSLASH) || _decodeBase64Escape(b64variant, ch, 3) != Base64Variant.BASE64_VALUE_PADDING) { throw reportInvalidBase64Char(b64variant, ch, 3, "expected padding character '"+b64variant.getPaddingChar()+"'"); bits = b64variant.decodeBase64Char(ch); if (bits < 0) { if (bits != Base64Variant.BASE64_VALUE_PADDING) { buffer[outputPtr++] = (byte) (decodedData >> 8); buffer[outputPtr++] = (byte) decodedData; if (b64variant.usesPadding()) {
return Boolean.FALSE; return ctxt.handleWeirdKey(_keyClass, key, "value not 'true' or 'false'"); case TYPE_BYTE: return ctxt.handleWeirdKey(_keyClass, key, "overflow, value cannot be represented as 8-bit value"); return ctxt.handleWeirdKey(_keyClass, key, "overflow, value cannot be represented as 16-bit value"); return ctxt.getConfig().getBase64Variant().decode(key); } catch (IllegalArgumentException e) { return _weirdKey(ctxt, key, e);
@Override public ByteBuffer readFromString(String s) { return ByteBuffer.wrap(Base64Variants.getDefaultVariant().decode(s)); }
/** * 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. * * @param input Byte array to encode */ public String encode(byte[] input) { return encode(input, false); }
/** * Helper method that can be used for base64 decoding in cases where * encoded content has already been read as a String. */ protected void _decodeBase64(String str, ByteArrayBuilder builder, Base64Variant b64variant) throws IOException { try { b64variant.decode(str, builder); } catch (IllegalArgumentException e) { _reportError(e.getMessage()); } }