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

/**
 * {@inheritDoc}
 */
@Override
public ExtensionClientOutput<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {

    String name = p.getParsingContext().getCurrentName();
    if (name == null) {
        name = p.getParsingContext().getParent().getCurrentName();
    }

    DeserializationConfig config = ctxt.getConfig();
    AnnotatedClass annotatedClass = AnnotatedClassResolver.resolveWithoutSuperTypes(config, ExtensionClientOutput.class);
    Collection<NamedType> namedTypes = config.getSubtypeResolver().collectAndResolveSubtypesByClass(config, annotatedClass);

    for (NamedType namedType : namedTypes) {
        if (Objects.equals(namedType.getName(), name)) {
            return (ExtensionClientOutput<?>) ctxt.readValue(p, namedType.getType());
        }
    }

    logger.warn("Unknown extension '{}' is contained.", name);
    return ctxt.readValue(p, UnknownExtensionClientOutput.class);
}
 

@Override
public CloudEvent deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    // In future we could eventually find a better solution avoiding this buffering step, but now this is the best option
    // Other sdk does the same in order to support all versions
    ObjectNode node = ctxt.readValue(p, ObjectNode.class);

    try {
        return new JsonMessage(p, node).read(CloudEventBuilder::fromSpecVersion);
    } catch (RuntimeException e) {
        // Yeah this is bad but it's needed to support checked exceptions...
        if (e.getCause() instanceof IOException) {
            throw (IOException) e.getCause();
        }
        throw MismatchedInputException.wrapWithPath(e, null);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public ExtensionAuthenticatorOutput<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {

    String name = p.getParsingContext().getCurrentName();
    if (name == null) {
        name = p.getParsingContext().getParent().getCurrentName();
    }

    DeserializationConfig config = ctxt.getConfig();
    AnnotatedClass annotatedClass = AnnotatedClassResolver.resolveWithoutSuperTypes(config, ExtensionAuthenticatorOutput.class);
    Collection<NamedType> namedTypes = config.getSubtypeResolver().collectAndResolveSubtypesByClass(config, annotatedClass);

    for (NamedType namedType : namedTypes) {
        if (Objects.equals(namedType.getName(), name)) {
            return (ExtensionAuthenticatorOutput<?>) ctxt.readValue(p, namedType.getType());
        }
    }

    logger.warn("Unknown extension '{}' is contained.", name);
    return ctxt.readValue(p, UnknownExtensionAuthenticatorOutput.class);
}
 

/**
 * {@inheritDoc}
 */
@Override
public AuthenticationExtensionClientInput<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {

    String name = p.getParsingContext().getCurrentName();
    if (name == null) {
        name = p.getParsingContext().getParent().getCurrentName();
    }

    DeserializationConfig config = ctxt.getConfig();
    AnnotatedClass annotatedClass = AnnotatedClassResolver.resolveWithoutSuperTypes(config, AuthenticationExtensionClientInput.class);
    Collection<NamedType> namedTypes = config.getSubtypeResolver().collectAndResolveSubtypesByClass(config, annotatedClass);

    for (NamedType namedType : namedTypes) {
        if (Objects.equals(namedType.getName(), name)) {
            return (AuthenticationExtensionClientInput<?>) ctxt.readValue(p, namedType.getType());
        }
    }

    logger.warn("Unknown extension '{}' is contained.", name);
    return ctxt.readValue(p, UnknownExtensionClientInput.class);
}
 

@Override
public DataStream deserialize( JsonParser jp, DeserializationContext ctxt) throws IOException {
    DataStream stream = org.kie.kogito.rules.DataSource.createStream();
    List list = ctxt.readValue( jp, collectionType );
    list.forEach( stream::append );
    return stream;
}
 

@Override
public FailedRequestStrategy deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
    final Configuration config = context.readValue(parser, Configuration.class);
    try {
        return config.getType().getType().getConstructor(Configuration.class).newInstance(config);
    } catch(InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException
        | SecurityException e) {
        LOGGER.error("Failed to instantiate strategy " + config.getType().getType().getCanonicalName() + "!", e);
        throw new OriannaException("Failed to instantiate strategy " + config.getType().getType().getCanonicalName()
            + "! Report this to the orianna team.", e);
    }
}
 

@Override
public DataStream deserialize( JsonParser jp, DeserializationContext ctxt) throws IOException {
    DataStream stream = DataSource.createStream();
    List list = ctxt.readValue( jp, collectionType );
    list.forEach( stream::append );
    return stream;
}
 

@Override
public DataStore deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    DataStore store = DataSource.createStore();
    List list = ctxt.readValue( jp, collectionType );
    list.forEach( store::add );
    return store;
}
 

@Override
public DataStream deserialize( JsonParser jp, DeserializationContext ctxt) throws IOException {
    DataStream stream = DataSource.createStream();
    List list = ctxt.readValue( jp, collectionType );
    list.forEach( stream::append );
    return stream;
}
 

@Override
public DataStore deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    DataStore store = DataSource.createStore();
    List list = ctxt.readValue( jp, collectionType );
    list.forEach( store::add );
    return store;
}
 

/**
 * {@inheritDoc}
 */
@Override
public AuthenticationExtensionsAuthenticatorOutputsEnvelope<? extends ExtensionAuthenticatorOutput<?>> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    JavaType javaType = SimpleType.constructUnsafe(AuthenticationExtensionsAuthenticatorOutputs.class);
    AuthenticationExtensionsAuthenticatorOutputs<? extends ExtensionAuthenticatorOutput<?>> authenticationExtensionsAuthenticatorOutputs = ctxt.readValue(p, javaType);
    int length = (int) p.getCurrentLocation().getByteOffset();
    return new AuthenticationExtensionsAuthenticatorOutputsEnvelope<>(authenticationExtensionsAuthenticatorOutputs, length);
}
 

protected ValueNode deserializeValueNode(JsonParser p, DeserializationContext context, JsonLocation startLocation)
        throws IOException {
    final Model model = (Model) context.getAttribute(ATTRIBUTE_MODEL);
    final AbstractNode parent = (AbstractNode) context.getAttribute(ATTRIBUTE_PARENT);
    final JsonPointer ptr = (JsonPointer) context.getAttribute(ATTRIBUTE_POINTER);

    Object v = context.readValue(p, Object.class);

    ValueNode node = model.valueNode(parent, ptr, v);
    node.setStartLocation(createLocation(startLocation));
    node.setEndLocation(createLocation(p.getCurrentLocation()));

    return node;
}
 

@Override
public M deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
    BigDecimal amount = null;
    CurrencyUnit currency = null;

    while (parser.nextToken() != JsonToken.END_OBJECT) {
        final String field = parser.getCurrentName();

        parser.nextToken();

        if (field.equals(names.getAmount())) {
            amount = context.readValue(parser, BigDecimal.class);
        } else if (field.equals(names.getCurrency())) {
            currency = context.readValue(parser, CurrencyUnit.class);
        } else if (field.equals(names.getFormatted())) {
            //noinspection UnnecessaryContinue
            continue;
        } else if (context.isEnabled(FAIL_ON_UNKNOWN_PROPERTIES)) {
            throw UnrecognizedPropertyException.from(parser, MonetaryAmount.class, field,
                    Arrays.asList(names.getAmount(), names.getCurrency(), names.getFormatted()));
        } else {
            parser.skipChildren();
        }
    }

    checkPresent(parser, amount, names.getAmount());
    checkPresent(parser, currency, names.getCurrency());

    return factory.create(amount, currency);
}
 

@Override
public FailedRequestStrategy deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
    final Configuration config = context.readValue(parser, Configuration.class);
    try {
        return config.getType().getType().getConstructor(Configuration.class).newInstance(config);
    } catch(InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException
        | SecurityException e) {
        LOGGER.error("Failed to instantiate strategy " + config.getType().getType().getCanonicalName() + "!", e);
        throw new OriannaException("Failed to instantiate strategy " + config.getType().getType().getCanonicalName()
            + "! Report this to the orianna team.", e);
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public COSEKeyEnvelope deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    COSEKey coseKey = ctxt.readValue(p, COSEKey.class);
    int length = (int) p.getCurrentLocation().getByteOffset();
    return new COSEKeyEnvelope(coseKey, length);
}
 

@Override
@SuppressWarnings("unchecked")
public Object deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
    Object substitute = deserializationContext.readValue(jsonParser, substituteType);
    return inputConverter.convertInput(substitute, detectedType, environment, valueMapper);
}
 

@Override
public AWSCredentialsProvider deserialize(JsonParser jsonParser, DeserializationContext context)
    throws IOException {
  return context.readValue(jsonParser, AWSCredentialsProvider.class);
}
 

@Override
public UnknownExtensionClientOutput deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    Serializable value = ctxt.readValue(p, Serializable.class);
    return new UnknownExtensionClientOutput(p.getCurrentName(), value);
}
 

@Override
public UnknownExtensionAuthenticatorOutput deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    Serializable value = ctxt.readValue(p, Serializable.class);
    return new UnknownExtensionAuthenticatorOutput(p.getCurrentName(), value);
}
 

@Override
public Object deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
    return deserializationContext.readValue(jsonParser, javaType);
}