public static ObjectMapper createObjectMapper() { final YAMLFactory yamlFactory = new YAMLFactory() .configure(YAMLGenerator.Feature.USE_NATIVE_TYPE_ID, false) .configure(YAMLGenerator.Feature.MINIMIZE_QUOTES, true) .configure(YAMLGenerator.Feature.ALWAYS_QUOTE_NUMBERS_AS_STRINGS, true) .configure(YAMLGenerator.Feature.USE_NATIVE_TYPE_ID, false); ObjectMapper mapper = new ObjectMapper(yamlFactory) .registerModule(new Jdk8Module()) .setSerializationInclusion(JsonInclude.Include.NON_EMPTY) .enable(SerializationFeature.INDENT_OUTPUT) .disable(SerializationFeature.WRITE_NULL_MAP_VALUES); for (Step step : ServiceLoader.load(Step.class, YamlHelpers.class.getClassLoader())) { mapper.registerSubtypes(new NamedType(step.getClass(), step.getKind())); } return mapper; }
@Override public void extendMapper(ObjectMapper mapper) { List<AttachmentSerializer> serializers = tracker.getBeanList(); for( AttachmentSerializer attachmentSerializer : serializers ) { Map<String, Class<? extends EquellaAttachmentBean>> types = attachmentSerializer.getAttachmentBeanTypes(); if( types != null ) { for( Entry<String, Class<? extends EquellaAttachmentBean>> entry : types.entrySet() ) { mapper.registerSubtypes(new NamedType(entry.getValue(), entry.getKey())); } } } }
public static ObjectMapper createObjectMapper() { final YAMLFactory yamlFactory = new YAMLFactory() .configure(YAMLGenerator.Feature.USE_NATIVE_TYPE_ID, false) .configure(YAMLGenerator.Feature.MINIMIZE_QUOTES, true) .configure(YAMLGenerator.Feature.ALWAYS_QUOTE_NUMBERS_AS_STRINGS, true) .configure(YAMLGenerator.Feature.USE_NATIVE_TYPE_ID, false); ObjectMapper mapper = new ObjectMapper(yamlFactory) .setSerializationInclusion(JsonInclude.Include.NON_EMPTY) .enable(SerializationFeature.INDENT_OUTPUT) .disable(SerializationFeature.WRITE_NULL_MAP_VALUES); for (Step step : ServiceLoader.load(Step.class, YamlHelpers.class.getClassLoader())) { mapper.registerSubtypes(new NamedType(step.getClass(), step.getKind())); } return mapper; }
@Override public List<NamedType> findSubtypes(Annotated a) { final ApiModel api = a.getAnnotation(ApiModel.class); if (api != null) { final Class<?>[] classes = api.subTypes(); final List<NamedType> names = new ArrayList<>(classes.length); for (Class<?> subType : classes) { names.add(new NamedType(subType)); } if (!names.isEmpty()) { return names; } } return Collections.emptyList(); }
private void assertConverterBeanAfterPropertiesSet( final String[] expectedPackageToScan, final Class<?>... expectedRegisterdClasses) { final ObjectMapper mapper = (ObjectMapper) ReflectionTestUtils.getField(converter, "mapper"); @SuppressWarnings("unchecked") final LinkedHashSet<NamedType> registeredSubtypes = (LinkedHashSet<NamedType>) ReflectionTestUtils .getField(mapper.getSubtypeResolver(), "_registeredSubtypes"); final List<Class<?>> expectedRegisterdClassesAsList = new ArrayList<>( Arrays.asList(expectedRegisterdClasses)); addStandardSpringCloudEventBusEvents(expectedRegisterdClassesAsList); assertTrue("Wrong RemoteApplicationEvent classes are registerd in object mapper", expectedRegisterdClassesAsList.size() == registeredSubtypes.size()); for (final NamedType namedType : registeredSubtypes) { assertTrue(expectedRegisterdClassesAsList.contains(namedType.getType())); } assertThat("RemoteApplicationEvent packages not registered", Arrays.asList((String[]) ReflectionTestUtils.getField(converter, "packagesToScan")), containsInAnyOrder(expectedPackageToScan)); }
public Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass paramAnnotatedClass, MapperConfig<?> paramMapperConfig, AnnotationIntrospector paramAnnotationIntrospector) { HashMap localHashMap = new HashMap(); if (this._registeredSubtypes != null) { Class localClass = paramAnnotatedClass.getRawType(); Iterator localIterator = this._registeredSubtypes.iterator(); while (localIterator.hasNext()) { NamedType localNamedType = (NamedType)localIterator.next(); if (localClass.isAssignableFrom(localNamedType.getType())) _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localNamedType.getType(), paramAnnotationIntrospector, paramMapperConfig), localNamedType, paramMapperConfig, paramAnnotationIntrospector, localHashMap); } } _collectAndResolve(paramAnnotatedClass, new NamedType(paramAnnotatedClass.getRawType(), null), paramMapperConfig, paramAnnotationIntrospector, localHashMap); return new ArrayList(localHashMap.values()); }
public TypeDeserializer buildTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, Collection<NamedType> paramCollection) { if (this._idType == JsonTypeInfo.Id.NONE) return null; TypeIdResolver localTypeIdResolver = idResolver(paramDeserializationConfig, paramJavaType, paramCollection, false, true); switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$As[this._includeAs.ordinal()]) { default: break; case 1: return new AsArrayTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl); case 2: return new AsPropertyTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl); case 3: return new AsWrapperTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl); case 4: return new AsExternalTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl); } throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: " + this._includeAs); }
public TypeSerializer buildTypeSerializer(SerializationConfig paramSerializationConfig, JavaType paramJavaType, Collection<NamedType> paramCollection) { if (this._idType == JsonTypeInfo.Id.NONE) return null; TypeIdResolver localTypeIdResolver = idResolver(paramSerializationConfig, paramJavaType, paramCollection, true, false); switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$As[this._includeAs.ordinal()]) { default: break; case 1: return new AsArrayTypeSerializer(localTypeIdResolver, null); case 2: return new AsPropertyTypeSerializer(localTypeIdResolver, null, this._typeProperty); case 3: return new AsWrapperTypeSerializer(localTypeIdResolver, null); case 4: return new AsExternalTypeSerializer(localTypeIdResolver, null, this._typeProperty); } throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: " + this._includeAs); }
protected TypeIdResolver idResolver(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, boolean paramBoolean1, boolean paramBoolean2) { if (this._customIdResolver != null) return this._customIdResolver; if (this._idType == null) throw new IllegalStateException("Can not build, 'init()' not yet called"); switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$Id[this._idType.ordinal()]) { default: break; case 1: return new ClassNameIdResolver(paramJavaType, paramMapperConfig.getTypeFactory()); case 2: return new MinimalClassNameIdResolver(paramJavaType, paramMapperConfig.getTypeFactory()); case 3: return TypeNameIdResolver.construct(paramMapperConfig, paramJavaType, paramCollection, paramBoolean1, paramBoolean2); case 4: return null; } throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: " + this._idType); }
private static synchronized void startRealtime() { if (rn == null) { final Lifecycle lifecycle = new Lifecycle(); rn = RealtimeNode.builder().build(); lifecycle.addManagedInstance(rn); rn.registerJacksonSubtype(new NamedType(StormFirehoseFactory.class, "storm")); Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() { @Override public void run() { LOG.info("Running shutdown hook"); lifecycle.stop(); } })); try { lifecycle.start(); } catch (Throwable t) { LOG.info("Throwable caught at startup, committing seppuku", t); t.printStackTrace(); System.exit(2); } } }
public CodecTypeIdResolver(PluginMap pluginMap, JavaType baseType, TypeFactory typeFactory, Collection<NamedType> subtypes, PluginRegistry pluginRegistry) { super(baseType, typeFactory); this.pluginRegistry = pluginRegistry; if (!subtypes.isEmpty()) { BiMap<String, Class<?>> mutableExtraSubTypes = HashBiMap.create(subtypes.size()); for (NamedType namedType : subtypes) { if (namedType.hasName()) { mutableExtraSubTypes.put(namedType.getName(), namedType.getType()); } } this.extraSubTypes = Maps.unmodifiableBiMap(mutableExtraSubTypes); } else { this.extraSubTypes = ImmutableBiMap.of(); } this.pluginMap = pluginMap; }
/** report all non-alias plugin types */ @Override public List<NamedType> findSubtypes(Annotated a) { Pluggable pluggable = a.getAnnotation(Pluggable.class); PluginMap pluginMap; if (pluggable != null) { pluginMap = pluginRegistry.byCategory().get(pluggable.value()); } else if (pluginRegistry.byClass().containsKey(a.getRawType())) { pluginMap = pluginRegistry.byClass().get(a.getRawType()); } else { return null; } List<NamedType> result = new ArrayList<>(pluginMap.asBiMap().size()); for (Map.Entry<String, Class<?>> type : pluginMap.asBiMap().entrySet()) { result.add(new NamedType(type.getValue(), type.getKey())); } return result; }
@Bean public ObjectMapper jacksonObjectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.setVisibility( mapper.getSerializationConfig().getDefaultVisibilityChecker() .withFieldVisibility(Visibility.ANY) .withGetterVisibility(Visibility.NONE) .withSetterVisibility(Visibility.NONE) .withCreatorVisibility(Visibility.NONE) .withIsGetterVisibility(Visibility.NONE)); SimpleModule module = new SimpleModule("bandwidth-on-demand", Version.unknownVersion()); module.addSerializer(new VlanJsonSerializer()); module.addDeserializer(Vlan.class, new VlanJsonDeserializer()); module.addSerializer(new ScheduleTypeJsonSerializer()); module.addDeserializer(ScheduleType.class, new ScheduleTypeJsonDeserializer()); mapper.registerModule(module); mapper.registerModule(new Hibernate4Module()); mapper.registerModule(new JodaModule()); mapper.registerModule(new Jdk8Module()); mapper.registerModule(new JavaTimeModule()); mapper.registerSubtypes(new NamedType(LocalVirtualPort.class, "LOCAL")); mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); return mapper; }
@Override public Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass type, MapperConfig<?> config, AnnotationIntrospector ai) { HashMap<NamedType, NamedType> subtypes = new HashMap<NamedType, NamedType>(); // [JACKSON-257] then consider registered subtypes (which have precedence over annotations) if (_registeredSubtypes != null) { Class<?> rawBase = type.getRawType(); for (NamedType subtype : _registeredSubtypes) { // is it a subtype of root type? if (rawBase.isAssignableFrom(subtype.getType())) { // yes AnnotatedClass curr = AnnotatedClass.constructWithoutSuperTypes(subtype.getType(), ai, config); _collectAndResolve(curr, subtype, config, ai, subtypes); } } } // and then check subtypes via annotations from base type (recursively) NamedType rootType = new NamedType(type.getRawType(), null); _collectAndResolve(type, rootType, config, ai, subtypes); return new ArrayList<NamedType>(subtypes.values()); }
public TypeSerializer buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes) { if (_idType == JsonTypeInfo.Id.NONE) { return null; } TypeIdResolver idRes = idResolver(config, baseType, subtypes, true, false); switch (_includeAs) { case WRAPPER_ARRAY: return new AsArrayTypeSerializer(idRes, null); case PROPERTY: return new AsPropertyTypeSerializer(idRes, null, _typeProperty); case WRAPPER_OBJECT: return new AsWrapperTypeSerializer(idRes, null); case EXTERNAL_PROPERTY: return new AsExternalTypeSerializer(idRes, null, _typeProperty); } throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: "+_includeAs); }
public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) { if (_idType == JsonTypeInfo.Id.NONE) { return null; } TypeIdResolver idRes = idResolver(config, baseType, subtypes, false, true); // First, method for converting type info to type id: switch (_includeAs) { case WRAPPER_ARRAY: return new AsArrayTypeDeserializer(baseType, idRes, _typeProperty, _typeIdVisible, _defaultImpl); case PROPERTY: return new AsPropertyTypeDeserializer(baseType, idRes, _typeProperty, _typeIdVisible, _defaultImpl); case WRAPPER_OBJECT: return new AsWrapperTypeDeserializer(baseType, idRes, _typeProperty, _typeIdVisible, _defaultImpl); case EXTERNAL_PROPERTY: return new AsExternalTypeDeserializer(baseType, idRes, _typeProperty, _typeIdVisible, _defaultImpl); } throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: "+_includeAs); }
/** * Helper method that will either return configured custom * type id resolver, or construct a standard resolver * given configuration. */ protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) { // Custom id resolver? if (_customIdResolver != null) { return _customIdResolver; } if (_idType == null) { throw new IllegalStateException("Can not build, 'init()' not yet called"); } switch (_idType) { case CLASS: return new ClassNameIdResolver(baseType, config.getTypeFactory()); case MINIMAL_CLASS: return new MinimalClassNameIdResolver(baseType, config.getTypeFactory()); case NAME: return TypeNameIdResolver.construct(config, baseType, subtypes, forSer, forDeser); case NONE: // hmmh. should never get this far with 'none' return null; case CUSTOM: // need custom resolver... } throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: "+_idType); }
/** * Method called to create a type information serializer for values of given * container property * if one is needed. If not needed (no polymorphic handling configured), should * return null. * * @param containerType Declared type of the container to use as the base type for type information serializer * * @return Type serializer to use for property value contents, if one is needed; null if not. */ public TypeSerializer findPropertyContentTypeSerializer(JavaType containerType, SerializationConfig config, AnnotatedMember accessor) throws JsonMappingException { JavaType contentType = containerType.getContentType(); AnnotationIntrospector ai = config.getAnnotationIntrospector(); TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, accessor, containerType); // Defaulting: if no annotations on member, check value class if (b == null) { return createTypeSerializer(config, contentType); } Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(accessor, config, ai, contentType); return b.buildTypeSerializer(config, contentType, subtypes); }
/** * Method called to construct a type serializer for values with given declared * base type. This is called for values other than those of bean property * types. */ @Override public TypeSerializer createTypeSerializer(SerializationConfig config, JavaType baseType) { BeanDescription bean = config.introspectClassAnnotations(baseType.getRawClass()); AnnotatedClass ac = bean.getClassInfo(); AnnotationIntrospector ai = config.getAnnotationIntrospector(); TypeResolverBuilder<?> b = ai.findTypeResolver(config, ac, baseType); /* Ok: if there is no explicit type info handler, we may want to * use a default. If so, config object knows what to use. */ Collection<NamedType> subtypes = null; if (b == null) { b = config.getDefaultTyper(baseType); } else { subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(ac, config, ai); } if (b == null) { return null; } return b.buildTypeSerializer(config, baseType, subtypes); }
/** * Method called to create a type information deserializer for values of * given non-container property, if one is needed. * If not needed (no polymorphic handling configured for property), should return null. *<p> * Note that this method is only called for non-container bean properties, * and not for values in container types or root values (or container properties) * * @param baseType Declared base type of the value to deserializer (actual * deserializer type will be this type or its subtype) * * @return Type deserializer to use for given base type, if one is needed; null if not. */ public TypeDeserializer findPropertyTypeDeserializer(DeserializationConfig config, JavaType baseType, AnnotatedMember annotated) throws JsonMappingException { AnnotationIntrospector ai = config.getAnnotationIntrospector(); TypeResolverBuilder<?> b = ai.findPropertyTypeResolver(config, annotated, baseType); // Defaulting: if no annotations on member, check value class if (b == null) { return findTypeDeserializer(config, baseType); } // but if annotations found, may need to resolve subtypes: Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes( annotated, config, ai, baseType); return b.buildTypeDeserializer(config, baseType, subtypes); }
/** * Method called to find and create a type information deserializer for values of * given container (list, array, map) property, if one is needed. * If not needed (no polymorphic handling configured for property), should return null. *<p> * Note that this method is only called for container bean properties, * and not for values in container types or root values (or non-container properties) * * @param containerType Type of property; must be a container type * @param propertyEntity Field or method that contains container property */ public TypeDeserializer findPropertyContentTypeDeserializer(DeserializationConfig config, JavaType containerType, AnnotatedMember propertyEntity) throws JsonMappingException { AnnotationIntrospector ai = config.getAnnotationIntrospector(); TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, propertyEntity, containerType); JavaType contentType = containerType.getContentType(); // Defaulting: if no annotations on member, check class if (b == null) { return findTypeDeserializer(config, contentType); } // but if annotations found, may need to resolve subtypes: Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes( propertyEntity, config, ai, contentType); return b.buildTypeDeserializer(config, contentType, subtypes); }
@Override public void extendMapper(ObjectMapper mapper) { mapper.registerSubtypes(new NamedType(RootFolderBean.class, RootFolderBean.TYPE)); mapper.registerSubtypes(new NamedType(FolderBean.class, FolderBean.TYPE)); mapper.registerSubtypes(new NamedType(FileBean.class, FileBean.TYPE)); mapper.registerSubtypes(new NamedType(GenericFileBean.class, GenericFileBean.TYPE)); }
/** * Configure type mapping for the {@literal value} field in the {@literal CredentialDetails} * object. * * @param objectMapper the {@link ObjectMapper} to configure */ private static void configureCredentialDetailTypeMapping(ObjectMapper objectMapper) { List<NamedType> subtypes = new ArrayList<NamedType>(); for (CredentialType type : CredentialType.values()) { subtypes.add(new NamedType(type.getModelClass(), type.getValueType())); } registerSubtypes(objectMapper, subtypes); }
/** * */ private static void register(ObjectMapper mapper, JacksonMapping mapping) { try { Class<?> clazz = Class.forName(mapping.getClassName()); mapper.registerSubtypes(new NamedType(clazz, mapping.getName())); } catch (ClassNotFoundException e) { throw new JRRuntimeException(e); } }
@Override public List<? extends Module> getJacksonModules() { // Register Jackson module for any classes we need to be able to use in JSON queries or ingestion specs. return ImmutableList.of( new SimpleModule(getClass().getSimpleName()).registerSubtypes( new NamedType(ExampleSumAggregatorFactory.class, ExampleSumAggregatorFactory.TYPE_NAME), new NamedType(ExampleExtractionFn.class, ExampleExtractionFn.TYPE_NAME) ) ); }
@Override public void register(SimpleModule pluginModule, SimpleModule resourceModule) { pluginModule.addAbstractTypeMapping(Reader.Creator.class, HiveReader.Creator.class); pluginModule.registerSubtypes(new NamedType(HiveReader.Creator.class, "hive")); pluginModule.addAbstractTypeMapping(Writer.Creator.class, HiveWriter.Creator.class); pluginModule.registerSubtypes(new NamedType(HiveWriter.Creator.class, "hive")); resourceModule.addAbstractTypeMapping(Resource.Creator.class, HiveConnection.Creator.class); resourceModule.registerSubtypes(new NamedType(HiveConnection.Creator.class, "hive")); }
@Override public void register(SimpleModule pluginModule, SimpleModule resourceModule) { pluginModule.addAbstractTypeMapping(Reader.Creator.class, MysqlReader.Creator.class); pluginModule.registerSubtypes(new NamedType(MysqlReader.Creator.class, "mysql")); pluginModule.addAbstractTypeMapping(Writer.Creator.class, MysqlWriter.Creator.class); pluginModule.registerSubtypes(new NamedType(MysqlWriter.Creator.class, "mysql")); resourceModule.addAbstractTypeMapping(Resource.Creator.class, MysqlConnection.Creator.class); resourceModule.registerSubtypes(new NamedType(MysqlConnection.Creator.class, "mysql")); }
@Override public void register(SimpleModule pluginModule, SimpleModule resourceModule) { pluginModule.addAbstractTypeMapping(Reader.Creator.class, MongoReader.Creator.class); pluginModule.registerSubtypes(new NamedType(MongoReader.Creator.class, "mongo")); resourceModule.addAbstractTypeMapping(Resource.Creator.class, MongoConnection.Creator.class); resourceModule.registerSubtypes(new NamedType(MongoConnection.Creator.class, "mongo")); }
@Override public void register(SimpleModule pluginModule, SimpleModule resourceModule) { pluginModule.addAbstractTypeMapping(Writer.Creator.class, HBaseWriter.Creator.class); pluginModule.registerSubtypes(new NamedType(HBaseWriter.Creator.class, "hbase")); resourceModule.addAbstractTypeMapping(Resource.Creator.class, HBaseConnection.Creator.class); resourceModule.registerSubtypes(new NamedType(HBaseConnection.Creator.class, "hbase")); }
private Map<Type, List<NamedType>> collectSubtypes(Set<Type> abstractTypes, String[] basePackages, TypeInfoGenerator metaDataGen) { Map<Type, List<NamedType>> types = new HashMap<>(); Set<Class<?>> abstractClasses = abstractTypes.stream() .map(ClassUtils::getRawType) .distinct() .collect(Collectors.toSet()); for (Class abstractClass : abstractClasses) { List<NamedType> subTypes = ClassUtils.findImplementations(abstractClass, basePackages).stream() .filter(impl -> !ClassUtils.isAbstract(impl)) .map(sub -> new NamedType(sub, metaDataGen.generateTypeName(GenericTypeReflector.annotate(sub)))) .collect(Collectors.toList()); types.put(abstractClass, subTypes); } return types; }
@Override public List<NamedType> findSubtypes(Annotated a) { List<NamedType> original = super.findSubtypes(a); if ((original == null || original.isEmpty()) && typeMap.containsKey(a.getRawType())) { return typeMap.get(a.getRawType()); } return original; }
@Override public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) { final TypeNameIdResolver typeNameIdResolver = TypeNameIdResolver.construct(config, baseType, subtypes, false, true); return new MetadataTypeDeserializer( baseType, typeNameIdResolver, this.defaultImpl == null ? null : config.getTypeFactory().constructSpecializedType(baseType, this.defaultImpl)); }
@Override public void registerSubtypes(NamedType... types) { if (locked) { throw new UnsupportedOperationException("This object is immutable"); } else { super.registerSubtypes(types); } }
@Before public void setup() { mapper = new ObjectMapper(); mapper.addMixIn(Aggregation.class, TypeNameMixin.class); mapper.registerModule(new Jdk8Module()); mapper.registerSubtypes(new NamedType(Group.class, Group.NAME)); mapper.registerSubtypes(new NamedType(Empty.class, Empty.NAME)); }
@Override protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) { if (_customIdResolver != null) { return _customIdResolver; } if (_idType == null) { throw new IllegalStateException("Can not build, 'init()' not yet called"); } if (_idType == JsonTypeInfo.Id.CLASS){ return new WideningClassNameIdResolver(baseType, config.getTypeFactory()); } return super.idResolver(config, baseType, subtypes, forSer, forDeser); //To change body of generated methods, choose Tools | Templates. }
@Override protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) { if (_idType == null) { throw new IllegalStateException("Can not build, 'init()' not yet called"); } return new NsTypeIdResolver(baseType, config.getTypeFactory(), basicMetaData); }
public static TypeNameIdResolver construct(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, boolean paramBoolean1, boolean paramBoolean2) { if (paramBoolean1 == paramBoolean2) throw new IllegalArgumentException(); HashMap localHashMap1 = null; if (paramBoolean1) localHashMap1 = new HashMap(); HashMap localHashMap2 = null; if (paramBoolean2) localHashMap2 = new HashMap(); if (paramCollection != null) { Iterator localIterator = paramCollection.iterator(); while (localIterator.hasNext()) { NamedType localNamedType = (NamedType)localIterator.next(); Class localClass = localNamedType.getType(); String str; if (localNamedType.hasName()) str = localNamedType.getName(); else str = _defaultTypeId(localClass); if (paramBoolean1) localHashMap1.put(localClass.getName(), str); if (paramBoolean2) { JavaType localJavaType = (JavaType)localHashMap2.get(str); if ((localJavaType == null) || (!localClass.isAssignableFrom(localJavaType.getRawClass()))) localHashMap2.put(str, paramMapperConfig.constructType(localClass)); } } } return new TypeNameIdResolver(paramMapperConfig, paramJavaType, localHashMap1, localHashMap2); }
public Collection<NamedType> collectAndResolveSubtypes(AnnotatedMember paramAnnotatedMember, MapperConfig<?> paramMapperConfig, AnnotationIntrospector paramAnnotationIntrospector, JavaType paramJavaType) { Class localClass; if (paramJavaType == null) localClass = paramAnnotatedMember.getRawType(); else localClass = paramJavaType.getRawClass(); HashMap localHashMap = new HashMap(); if (this._registeredSubtypes != null) { Iterator localIterator2 = this._registeredSubtypes.iterator(); while (localIterator2.hasNext()) { NamedType localNamedType3 = (NamedType)localIterator2.next(); if (localClass.isAssignableFrom(localNamedType3.getType())) _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localNamedType3.getType(), paramAnnotationIntrospector, paramMapperConfig), localNamedType3, paramMapperConfig, paramAnnotationIntrospector, localHashMap); } } List localList = paramAnnotationIntrospector.findSubtypes(paramAnnotatedMember); if (localList != null) { Iterator localIterator1 = localList.iterator(); while (localIterator1.hasNext()) { NamedType localNamedType2 = (NamedType)localIterator1.next(); _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localNamedType2.getType(), paramAnnotationIntrospector, paramMapperConfig), localNamedType2, paramMapperConfig, paramAnnotationIntrospector, localHashMap); } } NamedType localNamedType1 = new NamedType(localClass, null); _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localClass, paramAnnotationIntrospector, paramMapperConfig), localNamedType1, paramMapperConfig, paramAnnotationIntrospector, localHashMap); return new ArrayList(localHashMap.values()); }
public void registerSubtypes(NamedType[] paramArrayOfNamedType) { if (this._registeredSubtypes == null) this._registeredSubtypes = new LinkedHashSet(); int i = paramArrayOfNamedType.length; for (int j = 0; j < i; j++) { NamedType localNamedType = paramArrayOfNamedType[j]; this._registeredSubtypes.add(localNamedType); } }