com.fasterxml.jackson.databind.type.CollectionLikeType Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jackson-databind Show documentation
Show all versions of jackson-databind Show documentation
General data-binding functionality for Jackson: works on core streaming API
package com.fasterxml.jackson.databind.type;
import java.lang.reflect.TypeVariable;
import java.util.Collection;
import com.fasterxml.jackson.databind.JavaType;
/**
* Type that represents things that act similar to {@link java.util.Collection};
* but may or may not be instances of that interface.
* This specifically allows framework to check for configuration and annotation
* settings used for Map types, and pass these to custom handlers that may be more
* familiar with actual type.
*/
public class CollectionLikeType extends TypeBase
{
private static final long serialVersionUID = 1L;
/**
* Type of elements in collection
*/
protected final JavaType _elementType;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
protected CollectionLikeType(Class collT, TypeBindings bindings,
JavaType superClass, JavaType[] superInts, JavaType elemT,
Object valueHandler, Object typeHandler, boolean asStatic)
{
super(collT, bindings, superClass, superInts,
elemT.hashCode(), valueHandler, typeHandler, asStatic);
_elementType = elemT;
}
/**
* @since 2.7
*/
protected CollectionLikeType(TypeBase base, JavaType elemT)
{
super(base);
_elementType = elemT;
}
/**
* @since 2.7
*/
public static CollectionLikeType construct(Class rawType, TypeBindings bindings,
JavaType superClass, JavaType[] superInts, JavaType elemT) {
return new CollectionLikeType(rawType, bindings, superClass, superInts, elemT,
null, null, false);
}
/**
* @deprecated Since 2.7, use {@link #upgradeFrom} for constructing instances, given
* pre-resolved {@link SimpleType}.
*/
@Deprecated // since 2.7
public static CollectionLikeType construct(Class rawType, JavaType elemT) {
// First: may need to fabricate TypeBindings (needed for refining into
// concrete collection types, as per [databind#1102])
TypeVariable[] vars = rawType.getTypeParameters();
TypeBindings bindings;
if ((vars == null) || (vars.length != 1)) {
bindings = TypeBindings.emptyBindings();
} else {
bindings = TypeBindings.create(rawType, elemT);
}
return new CollectionLikeType(rawType, bindings,
_bogusSuperClass(rawType), null,
elemT, null, null, false);
}
/**
* Factory method that can be used to "upgrade" a basic type into collection-like
* one; usually done via {@link TypeModifier}
*
* @since 2.7
*/
public static CollectionLikeType upgradeFrom(JavaType baseType, JavaType elementType) {
// 19-Oct-2015, tatu: Not sure if and how other types could be used as base;
// will cross that bridge if and when need be
if (baseType instanceof TypeBase) {
return new CollectionLikeType((TypeBase) baseType, elementType);
}
throw new IllegalArgumentException("Cannot upgrade from an instance of "+baseType.getClass());
}
@Override
@Deprecated // since 2.7
protected JavaType _narrow(Class subclass) {
return new CollectionLikeType(subclass, _bindings,
_superClass, _superInterfaces, _elementType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType withContentType(JavaType contentType) {
if (_elementType == contentType) {
return this;
}
return new CollectionLikeType(_class, _bindings, _superClass, _superInterfaces,
contentType, _valueHandler, _typeHandler, _asStatic);
}
@Override
public CollectionLikeType withTypeHandler(Object h) {
return new CollectionLikeType(_class, _bindings,
_superClass, _superInterfaces, _elementType, _valueHandler, h, _asStatic);
}
@Override
public CollectionLikeType withContentTypeHandler(Object h)
{
return new CollectionLikeType(_class, _bindings,
_superClass, _superInterfaces, _elementType.withTypeHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public CollectionLikeType withValueHandler(Object h) {
return new CollectionLikeType(_class, _bindings,
_superClass, _superInterfaces, _elementType, h, _typeHandler, _asStatic);
}
@Override
public CollectionLikeType withContentValueHandler(Object h) {
return new CollectionLikeType(_class, _bindings,
_superClass, _superInterfaces, _elementType.withValueHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType withHandlersFrom(JavaType src) {
JavaType type = super.withHandlersFrom(src);
JavaType srcCt = src.getContentType();
if (srcCt != null) {
JavaType ct = _elementType.withHandlersFrom(srcCt);
if (ct != _elementType) {
type = type.withContentType(ct);
}
}
return type;
}
@Override
public CollectionLikeType withStaticTyping() {
if (_asStatic) {
return this;
}
return new CollectionLikeType(_class, _bindings,
_superClass, _superInterfaces, _elementType.withStaticTyping(),
_valueHandler, _typeHandler, true);
}
@Override
public JavaType refine(Class rawType, TypeBindings bindings,
JavaType superClass, JavaType[] superInterfaces) {
return new CollectionLikeType(rawType, bindings,
superClass, superInterfaces, _elementType,
_valueHandler, _typeHandler, _asStatic);
}
/*
/**********************************************************
/* Public API
/**********************************************************
*/
@Override
public boolean isContainerType() { return true; }
@Override
public boolean isCollectionLikeType() { return true; }
@Override
public JavaType getContentType() { return _elementType; }
@Override
public Object getContentValueHandler() {
return _elementType.getValueHandler();
}
@Override
public Object getContentTypeHandler() {
return _elementType.getTypeHandler();
}
@Override
public boolean hasHandlers() {
return super.hasHandlers() || _elementType.hasHandlers();
}
@Override
public StringBuilder getErasedSignature(StringBuilder sb) {
return _classSignature(_class, sb, true);
}
@Override
public StringBuilder getGenericSignature(StringBuilder sb) {
_classSignature(_class, sb, false);
sb.append('<');
_elementType.getGenericSignature(sb);
sb.append(">;");
return sb;
}
@Override
protected String buildCanonicalName() {
StringBuilder sb = new StringBuilder();
sb.append(_class.getName());
if (_elementType != null) {
sb.append('<');
sb.append(_elementType.toCanonical());
sb.append('>');
}
return sb.toString();
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Method that can be used for checking whether this type is a
* "real" Collection type; meaning whether it represents a parameterized
* subtype of {@link java.util.Collection} or just something that acts
* like one.
*/
public boolean isTrueCollectionType() {
return Collection.class.isAssignableFrom(_class);
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
CollectionLikeType other = (CollectionLikeType) o;
return (_class == other._class) && _elementType.equals(other._elementType);
}
@Override
public String toString()
{
return "[collection-like type; class "+_class.getName()+", contains "+_elementType+"]";
}
}