Java 类com.fasterxml.jackson.core.type.ResolvedType 实例源码

/**
 * Method to deserialize JSON content into a Java type, reference
 * to which is passed as argument. Type is passed using 
 * Jackson specific type; instance of which can be constructed using
 * {@link TypeFactory}.
 */
@Override
@SuppressWarnings("unchecked")
public final <T> T readValue(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonParseException, JsonMappingException
{
    return (T) _readValue(getDeserializationConfig(), jp, (JavaType) valueType);
}

@SuppressWarnings("unchecked")
@Override
public <T> T readValueAs(ResolvedType type) throws IOException {
    return (T) _objectReadContext.readValue(this, type);
}

@Override
public <T> T readValue(JsonParser p, ResolvedType type) throws IOException {
    return _reportUnsupportedOperation();
}

@Override
public <T> T readValueAs(ResolvedType type) throws IOException {
    return delegate.readValueAs(type);
}

public <T> T readValue(JsonParser paramJsonParser, ResolvedType paramResolvedType)
{
  return withType((JavaType)paramResolvedType).readValue(paramJsonParser);
}

public <T> Iterator<T> readValues(JsonParser paramJsonParser, ResolvedType paramResolvedType)
{
  return readValues(paramJsonParser, (JavaType)paramResolvedType);
}

@SuppressWarnings("unchecked")
@Override
public <T> T readValue(JsonParser p, ResolvedType type) throws IOException {
    return (T) readValue(p, type.getRawClass());
}

/**
 * Method for reading sequence of Objects from parser stream.
 * Sequence can be either root-level "unwrapped" sequence (without surrounding
 * JSON array), or a sequence contained in a JSON Array.
 * In either case {@link JsonParser} must point to the first token of
 * the first element, OR not point to any token (in which case it is advanced
 * to the next token). This means, specifically, that for wrapped sequences,
 * parser MUST NOT point to the surrounding <code>START_ARRAY</code> but rather
 * to the token following it.
 *<p>
 * Note that {@link ObjectReader} has more complete set of variants.
 */
@Override
public <T> MappingIterator<T> readValues(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonProcessingException
{
    return readValues(jp, (JavaType) valueType);
}

/**
 * @since 3.0
 */
public abstract <T> T readValueAs(ResolvedType type) throws IOException;

/**
 * Method to deserialize JSON content into a POJO, type specified
 * with fully resolved type object (so it can be a generic type,
 * including containers like {@link java.util.Collection} and
 * {@link java.util.Map}).
 */
public abstract <T> T readValue(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonProcessingException;

/**
 * Method for reading sequence of Objects from parser stream,
 * all with same specified value type.
 */
public abstract <T> Iterator<T> readValues(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonProcessingException;

/**
 * Convenience method that binds content read using given parser, using
 * configuration of this reader, except that expected value type
 * is specified with the call (instead of currently configured root type).
 * Value return is either newly constructed, or root value that
 * was specified with {@link #withValueToUpdate(Object)}.
 *<p>
 * NOTE: this method never tries to auto-detect format, since actual
 * (data-format specific) parser is given.
 */
@Override
@SuppressWarnings("unchecked")
public <T> T readValue(JsonParser jp, ResolvedType valueType) throws IOException, JsonProcessingException {
    return (T) withType((JavaType)valueType).readValue(jp);
}

/**
 * Convenience method that is equivalent to:
 *<pre>
 *   withType(valueType).readValues(jp);
 *</pre>
 *<p>
 * NOTE: this method never tries to auto-detect format, since actual
 * (data-format specific) parser is given.
 */
@Override
public <T> Iterator<T> readValues(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonProcessingException {
    return readValues(jp, (JavaType) valueType);
}

/**
 * Method to deserialize JSON content into a POJO, type specified
 * with fully resolved type object (so it can be a generic type,
 * including containers like {@link java.util.Collection} and
 * {@link java.util.Map}).
 */
public abstract <T> T readValue(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonProcessingException;

/**
 * Method for reading sequence of Objects from parser stream,
 * all with same specified value type.
 */
public abstract <T> Iterator<T> readValues(JsonParser jp, ResolvedType valueType)
    throws IOException, JsonProcessingException;

public <T> T readValue(JsonParser p, ResolvedType type) throws IOException;

public abstract <T> T readValue(JsonParser paramJsonParser, ResolvedType paramResolvedType);

public abstract <T> Iterator<T> readValues(JsonParser paramJsonParser, ResolvedType paramResolvedType);