Java Code Examples for com.fasterxml.jackson.databind.DeserializationContext#reportInputMismatch()

private static void validateRevisionNumber(DeserializationContext ctx, @Nullable JsonNode node,
                                           String type, boolean zeroAllowed) throws JsonMappingException {
    if (node == null) {
        ctx.reportInputMismatch(Revision.class, "missing %s revision number", type);
        // Should never reach here.
        throw new Error();
    }

    if (!node.canConvertToInt() || !zeroAllowed && node.intValue() == 0) {
        ctx.reportInputMismatch(Revision.class,
                                "A %s revision number must be %s integer.",
                                type, zeroAllowed ? "an" : "a non-zero");
        // Should never reach here.
        throw new Error();
    }
}
 

/**
 * Helper method called when {@link JsonParser} indicates that it can use
 * so-called native type ids, and such type id has been found.
 * 
 * @since 2.4
 */
protected Object _deserializeWithNativeTypeId(JsonParser jp, DeserializationContext ctxt, Object typeId)
    throws IOException
{
    JsonDeserializer<Object> deser;
    if (typeId == null) {
        /* 04-May-2014, tatu: Should error be obligatory, or should there be another method
         *   for "try to deserialize with native tpye id"?
         */
        deser = _findDefaultImplDeserializer(ctxt);
        if (deser == null) {
            return ctxt.reportInputMismatch(baseType(),
                    "No (native) type id found when one was expected for polymorphic type handling");
        }
    } else {
        String typeIdStr = (typeId instanceof String) ? (String) typeId : String.valueOf(typeId);
        deser = _findDeserializer(ctxt, typeIdStr);
    }
    return deser.deserialize(jp, ctxt);
}
 

@Nullable
@Override
public MediaType deserialize(JsonParser p, DeserializationContext ctx)
        throws IOException {
    final JsonNode tree = p.getCodec().readTree(p);
    if (!tree.isTextual()) {
        ctx.reportInputMismatch(MediaType.class, "media type must be a string.");
        return null;
    }

    final String textValue = tree.textValue();
    try {
        return MediaType.parse(textValue);
    } catch (IllegalArgumentException unused) {
        // Failed to parse.
        ctx.reportInputMismatch(MediaType.class, "malformed media type: " + textValue);
        return null;
    }
}
 

@Override
public Serializable deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    try (ByteArrayInputStream bais =
                 new ByteArrayInputStream(Base64.getDecoder().decode(p.readValueAs(String.class)));
         ObjectInputStream ois = new ObjectInputStream(bais)) {
        return (Serializable) ois.readObject();
    } catch (ClassNotFoundException e) {
        ctxt.reportInputMismatch(Serializable.class, "failed to deserialize a raw session: " + e);
        throw new Error(); // Should never reach here
    }
}
 

@Override
public CommitMessageDto deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    final JsonNode jsonNode = p.readValueAsTree();
    final JsonNode summary = jsonNode.get("summary");
    if (summary == null || summary.textValue() == null) {
        ctxt.reportInputMismatch(CommitMessageDto.class, "commit message should have a summary.");
        // should never reach here
        throw new Error();
    }

    final String detail = jsonNode.get("detail") == null ? "" : jsonNode.get("detail").textValue();
    final JsonNode markupNode = jsonNode.get("markup");
    final Markup markup = Markup.parse(markupNode == null ? "unknown" : markupNode.textValue());
    return new CommitMessageDto(summary.textValue(), detail, markup);
}
 

public char value(DeserializationContext ctx, JsonParser parser) throws IOException {
    String valueAsString = parser.getValueAsString();
    if (valueAsString.length() != 1) {
        ctx.reportInputMismatch(char.class,
                                "Cannot convert a JSON String of length %d into a char element of map",
                                valueAsString.length());
    }
    return valueAsString.charAt(0);
}
 

@Override
public T deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException {
    Intermediate intermediate = createIntermediate();

    if (p.isExpectedStartArrayToken()) {
        JsonToken t;
        while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
            String str;
            if (t == JsonToken.VALUE_STRING) {
                str = p.getText();
            } else {
                CharSequence cs =
                        (CharSequence) ctxt.handleUnexpectedToken(getValueType(ctxt), p);
                str = cs.toString();
            }
            if (str.length() != 1) {
                ctxt.reportInputMismatch(this,
                        "Cannot convert a JSON String of length %d into a char element of " +
                                "char array",
                        str.length());
            }
            add(intermediate, str.charAt(0));
        }
        return finish(intermediate);
    }

    char[] chars = p.getTextCharacters();
    addAll(intermediate, chars, p.getTextOffset(), p.getTextLength());
    return finish(intermediate);
}
 

private void addHeader(DeserializationContext ctx, HttpHeadersBuilder builder,
                       AsciiString name, JsonNode valueNode) throws JsonMappingException {
    if (valueNode.isTextual()) {
        builder.add(name, valueNode.asText());
    } else {
        ctx.reportInputMismatch(handledType(),
                                "HTTP header '%s' contains %s (%s); only strings are allowed.",
                                name, valueNode.getNodeType(), valueNode);
    }
}
 

private AssertionError reportInputMismatch(
        DeserializationContext context,
        String message
) throws JsonMappingException {
  context.reportInputMismatch(this, message);
  // the previous method should have thrown
  throw new AssertionError();
}
 

@Override
protected void populate(
        Value.Builder builder,
        JsonParser parser,
        DeserializationContext context
) throws IOException {
  switch (parser.getCurrentToken()) {
    case START_OBJECT:
      Object structValue = readValue(builder, STRUCT_FIELD, null, parser, context);
      builder.setField(STRUCT_FIELD, structValue);
      return;
    case START_ARRAY:
      Object listValue = readValue(builder, LIST_FIELD, null, parser, context);
      builder.setField(LIST_FIELD, listValue);
      return;
    case VALUE_STRING:
      builder.setStringValue(parser.getText());
      return;
    case VALUE_NUMBER_INT:
    case VALUE_NUMBER_FLOAT:
      builder.setNumberValue(parser.getValueAsDouble());
      return;
    case VALUE_TRUE:
      builder.setBoolValue(true);
      return;
    case VALUE_FALSE:
      builder.setBoolValue(false);
      return;
    case VALUE_NULL:
      builder.setNullValue(NullValue.NULL_VALUE);
      return;
    default:
      String message = "Can not deserialize instance of com.google.protobuf.Value out of " + parser.currentToken() + " token";
      context.reportInputMismatch(Value.class, message);
      // the previous method should have thrown
      throw new AssertionError();
  }
}
 

private static ServerPort fail(DeserializationContext ctx, JsonNode root) throws JsonMappingException {
    ctx.reportInputMismatch(ServerPort.class, "invalid server port information: %s", root);
    throw new Error(); // Should never reach here.
}
 

@Override
public Revision deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
    final JsonNode node = p.readValueAsTree();
    if (node.isNumber()) {
        validateRevisionNumber(ctx, node, "major", false);
        return new Revision(node.intValue());
    }

    if (node.isTextual()) {
        try {
            return new Revision(node.textValue());
        } catch (IllegalArgumentException e) {
            ctx.reportInputMismatch(Revision.class, e.getMessage());
            // Should never reach here.
            throw new Error();
        }
    }

    if (!node.isObject()) {
        ctx.reportInputMismatch(Revision.class,
                                "A revision must be a non-zero integer or " +
                                "an object that contains \"major\" and \"minor\" properties.");
        // Should never reach here.
        throw new Error();
    }

    final JsonNode majorNode = node.get("major");
    final JsonNode minorNode = node.get("minor");
    final int major;

    validateRevisionNumber(ctx, majorNode, "major", false);
    major = majorNode.intValue();
    if (minorNode != null) {
        validateRevisionNumber(ctx, minorNode, "minor", true);
        if (minorNode.intValue() != 0) {
            ctx.reportInputMismatch(Revision.class,
                                    "A revision must not have a non-zero \"minor\" property.");
        }
    }

    return new Revision(major);
}
 

@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    ctxt.reportInputMismatch(this, _message);
    return null;
}
 

@Override
public T deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException {
    Intermediate intermediate = createIntermediate();

    if (p.isExpectedStartArrayToken()) {
        JsonToken t;
        while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
            String str;
            if (t == JsonToken.VALUE_STRING) {
                str = p.getText();
            } else {
                CharSequence cs = (CharSequence) ctxt.handleUnexpectedToken(getValueType(ctxt), p);
                str = cs.toString();
            }
            if (str.length() != 1) {
                ctxt.reportInputMismatch(this,
                                         "Cannot convert a JSON String of length %d into a char element of " +
                                         "char array",
                                         str.length());
            }
            intermediate.add(str.charAt(0));
        }
        return finish(intermediate);
    }

    char[] chars = p.getTextCharacters();
    if (p.getTextOffset() == 0 && p.getTextLength() == chars.length) {
        intermediate.addAll(chars);
    } else {
        int i = 0;
        // first, copy in batches of BATCH_COPY_SIZE
        if ((p.getTextLength() - i) >= BATCH_COPY_SIZE) {
            char[] buf = new char[BATCH_COPY_SIZE];
            do {
                System.arraycopy(chars, p.getTextOffset() + i, buf, 0, BATCH_COPY_SIZE);
                intermediate.addAll(buf);
                i += BATCH_COPY_SIZE;
            } while ((p.getTextLength() - i) >= BATCH_COPY_SIZE);
        }
        // and finally, copy the remainder.
        if (p.getTextLength() > i) {
            char[] tail = Arrays.copyOfRange(
                    chars, p.getTextOffset() + i, p.getTextOffset() + p.getTextLength());
            intermediate.addAll(tail);
        }
    }
    return finish(intermediate);
}
 

@Override
public LocalDate deserialize(JsonParser parser, DeserializationContext context) throws IOException
{
    if (parser.hasToken(JsonToken.VALUE_STRING)) {
        String string = parser.getText().trim();
        if (string.length() == 0) {
            if (!isLenient()) {
                return _failForNotLenient(parser, context, JsonToken.VALUE_STRING);
            }
            return null;
        }
        // as per [datatype-jsr310#37], only check for optional (and, incorrect...) time marker 'T'
        // if we are using default formatter
        DateTimeFormatter format = _formatter;
        try {
            if (format == DEFAULT_FORMATTER) {
                // JavaScript by default includes time in JSON serialized Dates (UTC/ISO instant format).
                if (string.length() > 10 && string.charAt(10) == 'T') {
                   if (string.endsWith("Z")) {
                       return LocalDateTime.ofInstant(Instant.parse(string), ZoneOffset.UTC).toLocalDate();
                   } else {
                       return LocalDate.parse(string, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
                   }
                }
            }
            return LocalDate.parse(string, format);
        } catch (DateTimeException e) {
            return _handleDateTimeFormatException(context, e, format, string);
        }
    }
    if (parser.isExpectedStartArrayToken()) {
        JsonToken t = parser.nextToken();
        if (t == JsonToken.END_ARRAY) {
            return null;
        }
        if (context.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)
                && (t == JsonToken.VALUE_STRING || t==JsonToken.VALUE_EMBEDDED_OBJECT)) {
            final LocalDate parsed = deserialize(parser, context);
            if (parser.nextToken() != JsonToken.END_ARRAY) {
                handleMissingEndArrayForSingle(parser, context);
            }
            return parsed;            
        }
        if (t == JsonToken.VALUE_NUMBER_INT) {
            int year = parser.getIntValue();
            int month = parser.nextIntValue(-1);
            int day = parser.nextIntValue(-1);
            
            if (parser.nextToken() != JsonToken.END_ARRAY) {
                throw context.wrongTokenException(parser, handledType(), JsonToken.END_ARRAY,
                        "Expected array to end");
            }
            return LocalDate.of(year, month, day);
        }
        context.reportInputMismatch(handledType(),
                "Unexpected token (%s) within Array, expected VALUE_NUMBER_INT",
                t);
    }
    if (parser.hasToken(JsonToken.VALUE_EMBEDDED_OBJECT)) {
        return (LocalDate) parser.getEmbeddedObject();
    }
    // 06-Jan-2018, tatu: Is this actually safe? Do users expect such coercion?
    if (parser.hasToken(JsonToken.VALUE_NUMBER_INT)) {
        // issue 58 - also check for NUMBER_INT, which needs to be specified when serializing.
        if (_shape == JsonFormat.Shape.NUMBER_INT || isLenient()) {
            return LocalDate.ofEpochDay(parser.getLongValue());
        }
        return _failForNotLenient(parser, context, JsonToken.VALUE_STRING);
    }
    return _handleUnexpectedToken(context, parser, "Expected array or string.");
}
 

@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
    if (p.hasToken(JsonToken.VALUE_STRING)) {
        final String text = p.getText().trim();
        if (text.length() == 0) {
            CoercionAction act = ctxt.findCoercionAction(logicalType(), _valueClass,
                    CoercionInputShape.EmptyString);
            if (act == CoercionAction.Fail) {
                ctxt.reportInputMismatch(this,
    "Cannot coerce empty String (\"\") to %s (but could if enabling coercion using `CoercionConfig`)",
    _coercedTypeDesc());
            }
            if (act == CoercionAction.AsEmpty) {
                return getEmptyValue(ctxt);
            }
            // None of the types has specific null value
            return null;
        }
        try {
            switch (_typeSelector) {
            case TYPE_PERIOD:
                return Period.parse(text);
            case TYPE_ZONE_ID:
                return ZoneId.of(text);
            case TYPE_ZONE_OFFSET:
                return ZoneOffset.of(text);
            }
        } catch (DateTimeException e) {
            return _handleDateTimeException(ctxt, e, text);
        }
    }
    if (p.hasToken(JsonToken.VALUE_EMBEDDED_OBJECT)) {
        // 20-Apr-2016, tatu: Related to [databind#1208], can try supporting embedded
        //    values quite easily
        return p.getEmbeddedObject();
    }
    if (p.hasToken(JsonToken.START_ARRAY)){
        return _deserializeFromArray(p, ctxt);
    }
    
    throw ctxt.wrongTokenException(p, handledType(), JsonToken.VALUE_STRING, null);
}