Refine search
JsonToken t = p.getCurrentToken(); if (t == JsonToken.VALUE_STRING) { char[] buffer = p.getTextCharacters(); int offset = p.getTextOffset(); int len = p.getTextLength(); return Base64Variants.getDefaultVariant().encode((byte[]) ob, false).toCharArray();
/** * Method used to "demote" deserialized instances back to * canonical ones */ protected Object readResolve() { return Base64Variants.valueOf(_name); }
@Override public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException JsonToken curr = jp.getCurrentToken(); if (curr == JsonToken.VALUE_STRING) { return jp.getText(); jp.nextToken(); final String parsed = _parseString(jp, ctxt); if (jp.nextToken() != JsonToken.END_ARRAY) { return Base64Variants.getDefaultVariant().encode((byte[]) ob, false);
/** * Customized {@link TypeResolverBuilder} that provides type resolver builders * used with so-called "default typing" * (see {@link ObjectMapper#enableDefaultTyping()} for details). *<p> * Type resolver construction is based on configuration: implementation takes care * of only providing builders in cases where type information should be applied. * This is important since build calls may be sent for any and all types, and * type information should NOT be applied to all of them. */ public static class DefaultTypeResolverBuilder extends StdTypeResolverBuilder implements java.io.Serializable { private static final long serialVersionUID = 1L; /** * Definition of what types is this default typer valid for. */ protected final DefaultTyping _appliesFor; public DefaultTypeResolverBuilder(DefaultTyping t) { _appliesFor = t; } @Override public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) { return useForType(baseType) ? super.buildTypeDeserializer(config, baseType, subtypes) : null;
@Override public T deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JavaType javaType = ctxt.getTypeFactory().constructType(type); ObjectMapper mapper = (ObjectMapper) jp.getCodec(); if (jp.getCurrentToken() == JsonToken.VALUE_STRING) { return deserialize(mapper, jp.getText(), javaType); } else if (jp.getCurrentToken() == JsonToken.VALUE_EMBEDDED_OBJECT) { String json = new String(jp.getBinaryValue(Base64Variants.getDefaultVariant()), StandardCharsets.UTF_8); return deserialize(mapper, json, javaType); } else if(jp.getCurrentToken() == JsonToken.START_OBJECT || jp.getCurrentToken() == JsonToken.START_ARRAY) { return mapper.readValue(jp, javaType); } else { throw ctxt.mappingException("Expected JSON String"); } }
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);
@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); }
@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); }
/** * Similar to {@link #writeBinary(Base64Variant,byte[],int,int)}, * but assumes default to using the Jackson default Base64 variant * (which is {@link Base64Variants#MIME_NO_LINEFEEDS}). Also * assumes that whole byte array is to be output. */ public void writeBinary(byte[] data) throws IOException { writeBinary(Base64Variants.getDefaultVariant(), data, 0, data.length); }
/** * Hmmh. This is not quite as efficient as using {@link #serialize}, * but will work correctly. */ @Override public String asText() { return Base64Variants.getDefaultVariant().encode(_data, false); }
/** * Convenience alternative to {@link #getBinaryValue(Base64Variant)} * that defaults to using * {@link Base64Variants#getDefaultVariant} as the default encoding. */ public byte[] getBinaryValue() throws IOException { return getBinaryValue(Base64Variants.getDefaultVariant()); }
/** * Method that can be used as an alternative to {@link #getBigIntegerValue()}, * especially when value can be large. The main difference (beyond method * of returning content using {@link OutputStream} instead of as byte array) * is that content will NOT remain accessible after method returns: any content * processed will be consumed and is not buffered in any way. If caller needs * buffering, it has to implement it. * * @param out Output stream to use for passing decoded binary data * * @return Number of bytes that were decoded and written via {@link OutputStream} * * @since 2.1 */ public int readBinaryValue(OutputStream out) throws IOException { return readBinaryValue(Base64Variants.getDefaultVariant(), out); }
@Override public ByteBuffer readFromString(String s) { return ByteBuffer.wrap(Base64Variants.getDefaultVariant().decode(s)); }
@Override public byte[] binaryValue() throws IOException { return getBinaryValue(Base64Variants.getDefaultVariant()); }
@Override public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException JsonToken curr = jp.getCurrentToken(); if (curr == JsonToken.VALUE_STRING) { return jp.getText(); jp.nextToken(); final String parsed = _parseString(jp, ctxt); if (jp.nextToken() != JsonToken.END_ARRAY) { return Base64Variants.getDefaultVariant().encode((byte[]) ob, false);
/** * Customized {@link TypeResolverBuilder} that provides type resolver builders * used with so-called "default typing" * (see {@link ObjectMapper#enableDefaultTyping()} for details). *<p> * Type resolver construction is based on configuration: implementation takes care * of only providing builders in cases where type information should be applied. * This is important since build calls may be sent for any and all types, and * type information should NOT be applied to all of them. */ public static class DefaultTypeResolverBuilder extends StdTypeResolverBuilder implements java.io.Serializable { private static final long serialVersionUID = 1L; /** * Definition of what types is this default typer valid for. */ protected final DefaultTyping _appliesFor; public DefaultTypeResolverBuilder(DefaultTyping t) { _appliesFor = t; } @Override public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) { return useForType(baseType) ? super.buildTypeDeserializer(config, baseType, subtypes) : null;
@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); }
/** * Similar to {@link #writeBinary(Base64Variant,byte[],int,int)}, * but default to using the Jackson default Base64 variant * (which is {@link Base64Variants#MIME_NO_LINEFEEDS}). */ public void writeBinary(byte[] data, int offset, int len) throws IOException { writeBinary(Base64Variants.getDefaultVariant(), data, offset, len); }
/** * Different from other values, since contents need to be surrounded * by (double) quotes. */ @Override public String toString() { return Base64Variants.getDefaultVariant().encode(_data, true); } }
/** * Convenience alternative to {@link #getBinaryValue(Base64Variant)} * that defaults to using * {@link Base64Variants#getDefaultVariant} as the default encoding. */ public byte[] getBinaryValue() throws IOException { return getBinaryValue(Base64Variants.getDefaultVariant()); }