Skip to content

Commit

Permalink
Remove unused, deprecated (in 2.14) class "UntypedObjectDeseralizer.V…
Browse files Browse the repository at this point in the history 
…anilla" (#4973)
  • Loading branch information
@cowtowncoder
cowtowncoder authored Feb 13, 2025
1 parent 1819600 commit a545f7b
Showing 1 changed file with 11 additions and 342 deletions.
353 changes: 11 additions & 342 deletions src/main/java/com/fasterxml/jackson/databind/deser/std/UntypedObjectDeserializer.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -729,346 +729,15 @@ protected Object _deserializeFP(JsonParser p, DeserializationContext ctxt) throw
return p.getDoubleValue();
}

/*
/**********************************************************************
/* Separate "vanilla" implementation for common case of no deser overrides
/**********************************************************************
*/

/**
* Streamlined version of {@link UntypedObjectDeserializer} that has fewer checks and
* is only used when no custom deserializer overrides are applied.
*/
@JacksonStdImpl
@Deprecated // since 2.14, to be removed in near future
public static class Vanilla
extends StdDeserializer<Object>
{
private static final long serialVersionUID = 1L;

public final static Vanilla std = new Vanilla();

// @since 2.9
protected final boolean _nonMerging;

public Vanilla() { this(false); }

protected Vanilla(boolean nonMerging) {
super(Object.class);
_nonMerging = nonMerging;
}

public static Vanilla instance(boolean nonMerging) {
if (nonMerging) {
return new Vanilla(true);
}
return std;
}

@Override // since 2.12
public LogicalType logicalType() {
return LogicalType.Untyped;
}

@Override // since 2.9
public Boolean supportsUpdate(DeserializationConfig config) {
// 21-Apr-2017, tatu: Bit tricky... some values, yes. So let's say "dunno"
// 14-Jun-2017, tatu: Well, if merging blocked, can say no, as well.
return _nonMerging ? Boolean.FALSE : null;
}

@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
switch (p.currentTokenId()) {
case JsonTokenId.ID_START_OBJECT:
{
JsonToken t = p.nextToken();
if (t == JsonToken.END_OBJECT) {
return new LinkedHashMap<String,Object>(2);
}
}
case JsonTokenId.ID_FIELD_NAME:
return mapObject(p, ctxt);
case JsonTokenId.ID_START_ARRAY:
{
JsonToken t = p.nextToken();
if (t == JsonToken.END_ARRAY) { // and empty one too
if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
return NO_OBJECTS;
}
return new ArrayList<Object>(2);
}
}
if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
return mapArrayToArray(p, ctxt);
}
return mapArray(p, ctxt);
case JsonTokenId.ID_EMBEDDED_OBJECT:
return p.getEmbeddedObject();
case JsonTokenId.ID_STRING:
return p.getText();

case JsonTokenId.ID_NUMBER_INT:
if (ctxt.hasSomeOfFeatures(F_MASK_INT_COERCIONS)) {
return _coerceIntegral(p, ctxt);
}
return p.getNumberValue(); // should be optimal, whatever it is

case JsonTokenId.ID_NUMBER_FLOAT:
return _deserializeFP(p, ctxt);

case JsonTokenId.ID_TRUE:
return Boolean.TRUE;
case JsonTokenId.ID_FALSE:
return Boolean.FALSE;

case JsonTokenId.ID_END_OBJECT:
// 28-Oct-2015, tatu: [databind#989] We may also be given END_OBJECT (similar to FIELD_NAME),
// if caller has advanced to the first token of Object, but for empty Object
return new LinkedHashMap<String,Object>(2);

case JsonTokenId.ID_NULL: // 08-Nov-2016, tatu: yes, occurs
return null;

//case JsonTokenId.ID_END_ARRAY: // invalid
default:
}
return ctxt.handleUnexpectedToken(Object.class, p);
}

@Override
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException
{
switch (p.currentTokenId()) {
case JsonTokenId.ID_START_ARRAY:
case JsonTokenId.ID_START_OBJECT:
case JsonTokenId.ID_FIELD_NAME:
return typeDeserializer.deserializeTypedFromAny(p, ctxt);

case JsonTokenId.ID_STRING:
return p.getText();

case JsonTokenId.ID_NUMBER_INT:
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
return p.getBigIntegerValue();
}
return p.getNumberValue();

case JsonTokenId.ID_NUMBER_FLOAT:
return _deserializeFP(p, ctxt);

case JsonTokenId.ID_TRUE:
return Boolean.TRUE;
case JsonTokenId.ID_FALSE:
return Boolean.FALSE;
case JsonTokenId.ID_EMBEDDED_OBJECT:
return p.getEmbeddedObject();

case JsonTokenId.ID_NULL: // should not get this far really but...
return null;
default:
}
return ctxt.handleUnexpectedToken(Object.class, p);
}

@SuppressWarnings("unchecked")
@Override // since 2.9 (to support deep merge)
public Object deserialize(JsonParser p, DeserializationContext ctxt, Object intoValue)
throws IOException
{
if (_nonMerging) {
return deserialize(p, ctxt);
}
switch (p.currentTokenId()) {
case JsonTokenId.ID_END_OBJECT:
case JsonTokenId.ID_END_ARRAY:
return intoValue;
case JsonTokenId.ID_START_OBJECT:
{
JsonToken t = p.nextToken(); // to get to FIELD_NAME or END_OBJECT
if (t == JsonToken.END_OBJECT) {
return intoValue;
}
}
case JsonTokenId.ID_FIELD_NAME:
if (intoValue instanceof Map<?,?>) {
Map<Object,Object> m = (Map<Object,Object>) intoValue;
// NOTE: we are guaranteed to point to FIELD_NAME
String key = p.currentName();
do {
p.nextToken();
// and possibly recursive merge here
Object old = m.get(key);
Object newV;
if (old != null) {
newV = deserialize(p, ctxt, old);
} else {
newV = deserialize(p, ctxt);
}
if (newV != old) {
m.put(key, newV);
}
} while ((key = p.nextFieldName()) != null);
return intoValue;
}
break;
case JsonTokenId.ID_START_ARRAY:
{
JsonToken t = p.nextToken(); // to get to FIELD_NAME or END_OBJECT
if (t == JsonToken.END_ARRAY) {
return intoValue;
}
}

if (intoValue instanceof Collection<?>) {
Collection<Object> c = (Collection<Object>) intoValue;
// NOTE: merge for arrays/Collections means append, can't merge contents
do {
c.add(deserialize(p, ctxt));
} while (p.nextToken() != JsonToken.END_ARRAY);
return intoValue;
}
// 21-Apr-2017, tatu: Should we try to support merging of Object[] values too?
// ... maybe future improvement
break;
}
// Easiest handling for the rest, delegate. Only (?) question: how about nulls?
return deserialize(p, ctxt);
}

// @since 2.17
protected Object _deserializeFP(JsonParser p, DeserializationContext ctxt) throws IOException
{
JsonParser.NumberTypeFP nt = p.getNumberTypeFP();
if (nt == JsonParser.NumberTypeFP.BIG_DECIMAL) {
return p.getDecimalValue();
}
if (!p.isNaN()) {
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
return p.getDecimalValue();
}
}
if (nt == JsonParser.NumberTypeFP.FLOAT32) {
return p.getFloatValue();
}
return p.getDoubleValue();
}

protected Object mapArray(JsonParser p, DeserializationContext ctxt) throws IOException
{
Object value = deserialize(p, ctxt);
if (p.nextToken() == JsonToken.END_ARRAY) {
ArrayList<Object> l = new ArrayList<Object>(2);
l.add(value);
return l;
}
ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] values = buffer.resetAndStart();
int ptr = 0;
values[ptr++] = value;
int totalSize = ptr;
do {
value = deserialize(p, ctxt);
++totalSize;
if (ptr >= values.length) {
values = buffer.appendCompletedChunk(values);
ptr = 0;
}
values[ptr++] = value;
} while (p.nextToken() != JsonToken.END_ARRAY);
// let's create full array then
ArrayList<Object> result = new ArrayList<Object>(totalSize);
buffer.completeAndClearBuffer(values, ptr, result);
ctxt.returnObjectBuffer(buffer);
return result;
}

protected Object[] mapArrayToArray(JsonParser p, DeserializationContext ctxt) throws IOException {
ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] values = buffer.resetAndStart();
int ptr = 0;
do {
Object value = deserialize(p, ctxt);
if (ptr >= values.length) {
values = buffer.appendCompletedChunk(values);
ptr = 0;
}
values[ptr++] = value;
} while (p.nextToken() != JsonToken.END_ARRAY);
Object[] result = buffer.completeAndClearBuffer(values, ptr);
ctxt.returnObjectBuffer(buffer);
return result;
}

protected Object mapObject(JsonParser p, DeserializationContext ctxt) throws IOException
{
// will point to FIELD_NAME at this point, guaranteed
// 19-Jul-2021, tatu: Was incorrectly using "getText()" before 2.13, fixed for 2.13.0
String key1 = p.currentName();
p.nextToken();
Object value1 = deserialize(p, ctxt);

String key = p.nextFieldName();
if (key == null) { // single entry; but we want modifiable
LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(2);
result.put(key1, value1);
return result;
}
// And then the general case; default map size is 16
LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>();
result.put(key1, value1);
do {
p.nextToken();
final Object newValue = deserialize(p, ctxt);
final Object oldValue = result.put(key, newValue);
if (oldValue != null) {
return _mapObjectWithDups(p, ctxt, result, key, oldValue, newValue,
p.nextFieldName());
}
} while ((key = p.nextFieldName()) != null);
return result;
}

// NOTE: copied from above (alas, no easy way to share/reuse)
// @since 2.12 (wrt [databind#2733]
protected Object _mapObjectWithDups(JsonParser p, DeserializationContext ctxt,
final Map<String, Object> result, String initialKey,
Object oldValue, Object newValue, String nextKey) throws IOException
{
final boolean squashDups = ctxt.isEnabled(StreamReadCapability.DUPLICATE_PROPERTIES);

if (squashDups) {
_squashDups(result, initialKey, oldValue, newValue);
}

while (nextKey != null) {
p.nextToken();
newValue = deserialize(p, ctxt);
oldValue = result.put(nextKey, newValue);
if ((oldValue != null) && squashDups) {
_squashDups(result, nextKey, oldValue, newValue);
}
nextKey = p.nextFieldName();
}

return result;
}

// NOTE: copied from above (alas, no easy way to share/reuse)
@SuppressWarnings("unchecked")
private void _squashDups(final Map<String, Object> result, String key,
Object oldValue, Object newValue)
{
if (oldValue instanceof List<?>) {
((List<Object>) oldValue).add(newValue);
result.put(key, oldValue);
} else {
ArrayList<Object> l = new ArrayList<>();
l.add(oldValue);
l.add(newValue);
result.put(key, l);
}
}
}
}
// Separate "vanilla" implementation for common case of no deser overrides
// Streamlined version of {@link UntypedObjectDeserializer} that has fewer checks and
// is only used when no custom deserializer overrides are applied.
//
//@JacksonStdImpl
//@Deprecated // since 2.14, to be removed in near future
//
// Was removed from 2.19
//
// public static class Vanilla extends StdDeserializer<Object> { }
}

0 comments on commit a545f7b

Please sign in to comment.