Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.codehaus.jackson.map.ser.ArraySerializers Maven / Gradle / Ivy
Data Mapper package is a high-performance data binding package
built on Jackson JSON processor
package org.codehaus.jackson.map.ser;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Type;
import org.codehaus.jackson.*;
import org.codehaus.jackson.schema.SchemaAware;
import org.codehaus.jackson.schema.JsonSchema;
import org.codehaus.jackson.type.JavaType;
import org.codehaus.jackson.node.ObjectNode;
import org.codehaus.jackson.map.*;
import org.codehaus.jackson.map.type.TypeFactory;
import org.codehaus.jackson.map.type.ArrayType;
/**
* Dummy container class to group standard array serializer implementations.
*
* TODO: as per [JACKSON-55], should try to add path info for all serializers;
* is still missing those for some container types.
*/
public final class ArraySerializers
{
private ArraySerializers() { }
/*
////////////////////////////////////////////////////////////
// Concrete serializers, arrays
////////////////////////////////////////////////////////////
*/
/**
* Generic serializer for Object arrays (Object[]).
*/
public final static class ObjectArraySerializer
extends SerializerBase
{
public final static ObjectArraySerializer instance = new ObjectArraySerializer();
@Override
public void serialize(Object[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
final int len = value.length;
if (len > 0) {
JsonSerializer prevSerializer = null;
Class prevClass = null;
int i = 0;
for (; i < len; ++i) {
Object elem = value[i];
if (elem == null) {
provider.getNullValueSerializer().serialize(null, jgen, provider);
} else {
// Minor optimization to avoid most lookups:
Class cc = elem.getClass();
JsonSerializer currSerializer;
if (cc == prevClass) {
currSerializer = prevSerializer;
} else {
currSerializer = provider.findValueSerializer(cc);
prevSerializer = currSerializer;
prevClass = cc;
}
try {
currSerializer.serialize(elem, jgen, provider);
} catch (IOException ioe) {
throw ioe;
} catch (Exception e) {
// [JACKSON-55] Need to add reference information
/* 05-Mar-2009, tatu: But one nasty edge is when we get
* StackOverflow: usually due to infinite loop. But that gets
* hidden within an InvocationTargetException...
*/
Throwable t = e;
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) {
throw (Error) t;
}
throw JsonMappingException.wrapWithPath(t, elem, i);
}
}
}
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
throws JsonMappingException
{
ObjectNode o = createSchemaNode("array", true);
if (typeHint != null) {
JavaType javaType = TypeFactory.fromType(typeHint);
if (javaType.isArrayType()) {
Class componentType = ((ArrayType) javaType).getComponentType().getRawClass();
JsonSerializer ser = provider.findValueSerializer(componentType);
JsonNode schemaNode = (ser instanceof SchemaAware) ?
((SchemaAware) ser).getSchema(provider, null) :
JsonSchema.getDefaultSchemaNode();
o.put("items", schemaNode);
}
}
return o;
}
}
public final static class StringArraySerializer
extends SerializerBase
{
@Override
public void serialize(String[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
final int len = value.length;
if (len > 0) {
/* 08-Dec-2008, tatus: If we want this to be fully overridable
* (for example, to support String cleanup during writing
* or something), we should find serializer by provider.
* But for now, that seems like an overkill: and caller can
* add custom serializer if that is needed as well.
* (ditto for null values)
*/
//JsonSerializer ser = (JsonSerializer)provider.findValueSerializer(String.class);
for (int i = 0; i < len; ++i) {
String str = value[i];
if (str == null) {
jgen.writeNull();
} else {
//ser.serialize(value[i], jgen, provider);
jgen.writeString(value[i]);
}
}
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("string");
o.put("items", itemSchema);
return o;
}
}
public final static class BooleanArraySerializer
extends SerializerBase
{
@Override
public void serialize(boolean[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
for (int i = 0, len = value.length; i < len; ++i) {
jgen.writeBoolean(value[i]);
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("boolean");
o.put("items", itemSchema);
return o;
}
}
/**
* Unlike other integral number array serializers, we do not just print out byte values
* as numbers. Instead, we assume that it would make more sense to output content
* as base64 encoded bytes (using default base64 encoding).
*/
public final static class ByteArraySerializer
extends SerializerBase
{
@Override
public void serialize(byte[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeBinary(value);
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("string"); //binary values written as strings?
o.put("items", itemSchema);
return o;
}
}
public final static class ShortArraySerializer
extends SerializerBase
{
@SuppressWarnings("cast")
@Override
public void serialize(short[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
for (int i = 0, len = value.length; i < len; ++i) {
jgen.writeNumber((int)value[i]);
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("integer"); //no "short" type defined by json
o.put("items", itemSchema);
return o;
}
}
/**
* Character arrays are different from other integral number arrays in that
* they are most likely to be textual data, and should be written as
* Strings, not arrays of entries.
*/
public final static class CharArraySerializer
extends SerializerBase
{
@Override
public void serialize(char[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeString(value, 0, value.length);
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("string");
itemSchema.put("type", "string");
o.put("items", itemSchema);
return o;
}
}
public final static class IntArraySerializer
extends SerializerBase
{
@Override
public void serialize(int[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
for (int i = 0, len = value.length; i < len; ++i) {
jgen.writeNumber(value[i]);
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("integer");
o.put("items", itemSchema);
return o;
}
}
public final static class LongArraySerializer
extends SerializerBase
{
@Override
public void serialize(long[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
for (int i = 0, len = value.length; i < len; ++i) {
jgen.writeNumber(value[i]);
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("number", true);
o.put("items", itemSchema);
return o;
}
}
public final static class FloatArraySerializer
extends SerializerBase
{
@Override
public void serialize(float[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
for (int i = 0, len = value.length; i < len; ++i) {
jgen.writeNumber(value[i]);
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("number");
o.put("items", itemSchema);
return o;
}
}
public final static class DoubleArraySerializer
extends SerializerBase
{
@Override
public void serialize(double[] value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeStartArray();
for (int i = 0, len = value.length; i < len; ++i) {
jgen.writeNumber(value[i]);
}
jgen.writeEndArray();
}
//@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("array", true);
ObjectNode itemSchema = createSchemaNode("number");
o.put("items", itemSchema);
return o;
}
}
}
