1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
package com.fasterxml.jackson.databind.jsontype;
import java.util.Collection;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
/**
* Helper object used for handling registration on resolving of super-types
* to sub-types.
*/
public abstract class SubtypeResolver
{
/**
* Method called by {@code ObjectMapper.copy()} to make sure that
* {@link SubtypeResolver} instances used by two independent mappers
* can not cause thread-safety issues: if resolver is immutable, it
* may return {@code this}, but if not, it should create a copy with
* same configuration and return that instead.
*
* @return Either new instance with same configuration as this one (if
* instances are mutable), or this instance (if immutable)
*
* @since 2.12
*/
public SubtypeResolver copy() {
return this;
}
/*
/**********************************************************
/* Methods for registering external subtype definitions (init/config)
/**********************************************************
*/
/**
* Method for registering specified subtypes (possibly including type
* names); for type entries without name, non-qualified class name
* as used as name (unless overridden by annotation).
*/
public abstract void registerSubtypes(NamedType... types);
public abstract void registerSubtypes(Class<?>... classes);
/**
* @since 2.9
*/
public abstract void registerSubtypes(Collection<Class<?>> subtypes);
/*
/**********************************************************
/* Subtype resolution (public API)
/**********************************************************
*/
/**
* Method for finding out all reachable subtypes for a property specified
* by given element (method or field),
* such that access is by type,
* typically needed for serialization (converting from type to type name).
*
* @param baseType Effective property base type to use; may differ from
* actual type of property; for structured types it is content (value) type and NOT
* structured type.
*
* @since 2.6
*/
public Collection<NamedType> collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedMember property, JavaType baseType) {
// for backwards compatibility...
return collectAndResolveSubtypes(property, config,
config.getAnnotationIntrospector(), baseType);
}
/**
* Method for finding out all reachable subtypes for given type,
* such that access is by type,
* typically needed for serialization (converting from type to type name).
*
* @param baseType Effective property base type to use; may differ from
* actual type of property; for structured types it is content (value) type and NOT
* structured type.
*
* @since 2.6
*/
public Collection<NamedType> collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedClass baseType) {
// for backwards compatibility...
return collectAndResolveSubtypes(baseType, config, config.getAnnotationIntrospector());
}
/**
* Method for finding out all reachable subtypes for a property specified
* by given element (method or field),
* such that access is by type id,
* typically needed for deserialization (converting from type id to type).
*
* @param baseType Effective property base type to use; may differ from
* actual type of property; for structured types it is content (value) type and NOT
* structured type.
*
* @since 2.6
*/
public Collection<NamedType> collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedMember property, JavaType baseType) {
// for backwards compatibility...
return collectAndResolveSubtypes(property, config,
config.getAnnotationIntrospector(), baseType);
}
/**
* Method for finding out all reachable subtypes for given type,
* such that access is by type id,
* typically needed for deserialization (converting from type id to type).
*
* @param baseType Effective property base type to use; may differ from
* actual type of property; for structured types it is content (value) type and NOT
* structured type.
*
* @since 2.6
*/
public Collection<NamedType> collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedClass baseType) {
// for backwards compatibility...
return collectAndResolveSubtypes(baseType, config, config.getAnnotationIntrospector());
}
/*
/**********************************************************
/* Deprecated methods
/**********************************************************
*/
/**
* @deprecated Since 2.6 Use either
* {@link #collectAndResolveSubtypesByClass(MapperConfig, AnnotatedMember, JavaType)}
* or {@link #collectAndResolveSubtypesByTypeId(MapperConfig, AnnotatedMember, JavaType)}
* instead.
*/
@Deprecated
public Collection<NamedType> collectAndResolveSubtypes(AnnotatedMember property,
MapperConfig<?> config, AnnotationIntrospector ai, JavaType baseType) {
return collectAndResolveSubtypesByClass(config, property, baseType);
}
/**
* @deprecated Since 2.6 Use either
* {@link #collectAndResolveSubtypesByClass(MapperConfig, AnnotatedClass)}
* or {@link #collectAndResolveSubtypesByTypeId(MapperConfig, AnnotatedClass)}
* instead.
*/
@Deprecated
public Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass baseType,
MapperConfig<?> config, AnnotationIntrospector ai) {
return collectAndResolveSubtypesByClass(config, baseType);
}
}
|
