@JacksonStdImpl public final static class ByteDeserializer extends PrimitiveOrWrapperDeserializer<Byte> { public ByteDeserializer(Class<Byte> cls, Byte nvl) { super(cls, nvl); } @Override public Byte deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { return _parseByte(jp, ctxt); } }
@JacksonStdImpl public final static class ShortDeserializer extends PrimitiveOrWrapperDeserializer<Short> { public ShortDeserializer(Class<Short> cls, Short nvl) { super(cls, nvl); } @Override public Short deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { return _parseShort(jp, ctxt); } }
@JacksonStdImpl public final static class LongDeserializer extends PrimitiveOrWrapperDeserializer<Long> { public LongDeserializer(Class<Long> cls, Long nvl) { super(cls, nvl); } @Override public Long deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { return _parseLong(jp, ctxt); } }
@JacksonStdImpl public final static class SqlTimeSerializer extends ScalarSerializerBase<java.sql.Time> { public SqlTimeSerializer() { super(java.sql.Time.class); } @Override public void serialize(java.sql.Time value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeString(value.toString()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("string", true); } }
@JacksonStdImpl public final static class FloatSerializer extends ScalarSerializerBase<Float> { final static FloatSerializer instance = new FloatSerializer(); public FloatSerializer() { super(Float.class); } @Override public void serialize(Float value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeNumber(value.floatValue()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("number", true); } }
@JacksonStdImpl public final static class LongSerializer extends ScalarSerializerBase<Long> { final static LongSerializer instance = new LongSerializer(); public LongSerializer() { super(Long.class); } @Override public void serialize(Long value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeNumber(value.longValue()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("number", true); } }
@JacksonStdImpl public final static class FloatDeserializer extends PrimitiveOrWrapperDeserializer<Float> { public FloatDeserializer(Class<Float> cls, Float nvl) { super(cls, nvl); } @Override public Float deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { /* 22-Jan-2009, tatu: Bounds/range checks would be tricky * here, so let's not bother even trying... */ return _parseFloat(jp, ctxt); } }
/** * @deprecated Since 1.9, use {@link org.codehaus.jackson.map.ser.std.DateSerializer} instead */ @Deprecated @JacksonStdImpl public final static class UtilDateSerializer extends org.codehaus.jackson.map.ser.std.DateSerializer { }
/** * @deprecated Since 1.9 use {@link org.codehaus.jackson.map.ser.std.ToStringSerializer} */ @Deprecated @JacksonStdImpl public final class ToStringSerializer extends org.codehaus.jackson.map.ser.std.ToStringSerializer { public final static ToStringSerializer instance = new ToStringSerializer(); }
/** * Compared to regular {@link UtilDateSerializer}, we do use String * representation here. Why? Basically to truncate of time part, since * that should not be used by plain SQL date. */ @JacksonStdImpl public final static class SqlDateSerializer extends ScalarSerializerBase<java.sql.Date> { public SqlDateSerializer() { super(java.sql.Date.class); } @Override public void serialize(java.sql.Date value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeString(value.toString()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { //todo: (ryan) add a format for the date in the schema? return createSchemaNode("string", true); } }
/** * @deprecated Since 1.9, use {@link org.codehaus.jackson.map.ser.std.DateSerializer} instead */ @Deprecated @JacksonStdImpl public final static class SerializableSerializer extends org.codehaus.jackson.map.ser.std.SerializableSerializer { }
/** * @deprecated Since 1.9 use {@link org.codehaus.jackson.map.ser.std.EnumSerializer} */ @Deprecated @JacksonStdImpl public class EnumSerializer extends org.codehaus.jackson.map.ser.std.EnumSerializer { public EnumSerializer(EnumValues v) { super(v); } }
@JacksonStdImpl public final static class BooleanDeserializer extends PrimitiveOrWrapperDeserializer<Boolean> { public BooleanDeserializer(Class<Boolean> cls, Boolean nvl) { super(cls, nvl); } @Override public Boolean deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { return _parseBoolean(jp, ctxt); } // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double): // (is it an error to even call this version?) @Override public Boolean deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { return _parseBoolean(jp, ctxt); } }
@JacksonStdImpl public final static class DoubleDeserializer extends PrimitiveOrWrapperDeserializer<Double> { public DoubleDeserializer(Class<Double> cls, Double nvl) { super(cls, nvl); } @Override public Double deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { return _parseDouble(jp, ctxt); } // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double): // (is it an error to even call this version?) @Override public Double deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { return _parseDouble(jp, ctxt); } }
@JacksonStdImpl public final static class IntegerDeserializer extends PrimitiveOrWrapperDeserializer<Integer> { public IntegerDeserializer(Class<Integer> cls, Integer nvl) { super(cls, nvl); } @Override public Integer deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { return _parseInteger(jp, ctxt); } // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double): // (is it an error to even call this version?) @Override public Integer deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException, JsonProcessingException { return _parseInteger(jp, ctxt); } }
/** * @deprecated Since 1.9, use {@link org.codehaus.jackson.map.ser.std.DateSerializer} instead */ @JacksonStdImpl @Deprecated public final static class CalendarSerializer extends org.codehaus.jackson.map.ser.std.CalendarSerializer { }
/** * @deprecated Since 1.9, use {@link org.codehaus.jackson.map.ser.std.DateSerializer} instead */ @Deprecated @JacksonStdImpl public final static class SerializableWithTypeSerializer extends org.codehaus.jackson.map.ser.std.SerializableWithTypeSerializer { } }
/** * This is the special serializer for regular {@link java.lang.String}s. *<p> * Since this is one of "native" types, no type information is ever * included on serialization (unlike for most scalar types as of 1.5) */ @JacksonStdImpl public final class StringSerializer extends NonTypedScalarSerializerBase<String> { public StringSerializer() { super(String.class); } @Override public void serialize(String value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeString(value); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("string", true); } }
/** * Similar to {@link IntegerSerializer}, but will not cast to Integer: * instead, cast is to {@link java.lang.Number}, and conversion is * by calling {@link java.lang.Number#intValue}. */ @JacksonStdImpl public final static class IntLikeSerializer extends ScalarSerializerBase<Number> { final static IntLikeSerializer instance = new IntLikeSerializer(); public IntLikeSerializer() { super(Number.class); } @Override public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeNumber(value.intValue()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("integer", true); } }
/** * This is the special serializer for regular {@link java.lang.Integer}s * (and primitive ints) *<p> * Since this is one of "native" types, no type information is ever * included on serialization (unlike for most scalar types as of 1.5) */ @JacksonStdImpl public final static class IntegerSerializer extends NonTypedScalarSerializerBase<Integer> { public IntegerSerializer() { super(Integer.class); } @Override public void serialize(Integer value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { jgen.writeNumber(value.intValue()); } @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) { return createSchemaNode("integer", true); } }