Refine search
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME) @JsonSubTypes({ @Type(name = "I", value = Integer.class), @Type(name = "O", value = Double.class) }) // the annotation will be copied to a builder setter public abstract @Nullable Object value();
@Override public List<NamedType> findSubtypes(Annotated a) { JsonSubTypes t = _findAnnotation(a, JsonSubTypes.class); if (t == null) return null; JsonSubTypes.Type[] types = t.value(); ArrayList<NamedType> result = new ArrayList<NamedType>(types.length); for (JsonSubTypes.Type type : types) { result.add(new NamedType(type.value(), type.name())); } return result; }
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "ruleType") @JsonSubTypes({ @Type(value = JVM.class) }) @ApiModel(subTypes = { JVM.class }, discriminator = "ruleType") public class InstrumentRule { @JsonInclude private String ruleName; @JsonInclude private List<String> notes = new ArrayList<String>();
final JsonSubTypes jsonSubTypes = beanClass.getAnnotation(JsonSubTypes.class); final JsonTypeInfo jsonTypeInfo = beanClass.getAnnotation(JsonTypeInfo.class); if (jsonSubTypes != null && jsonTypeInfo != null && jsonTypeInfo.include() == JsonTypeInfo.As.PROPERTY) { final String propertyName = jsonTypeInfo.property(); for (JsonSubTypes.Type subType : jsonSubTypes.value()) { String propertyValue = null; if (jsonTypeInfo.use() == JsonTypeInfo.Id.NAME) { if (subType.name().equals("")) { final JsonTypeName jsonTypeName = subType.value().getAnnotation(JsonTypeName.class); if (jsonTypeName != null) { propertyValue = jsonTypeName.value(); propertyValue = subType.name(); final String subTypeName = findTypeName(subType.value(), model); if (baseTypeName != null && subTypeName != null) { writer.writeIndentedLine("");
@Override public void injectFields(final TypescriptInterface iface, final Class<?> javaClass) { final JsonTypeInfo typeInfoAnnotation = javaClass.getSuperclass().getAnnotation(JsonTypeInfo.class); final JsonSubTypes subTypesAnnotation = javaClass.getSuperclass().getAnnotation(JsonSubTypes.class); for (JsonSubTypes.Type subType : subTypesAnnotation.value()) { if (subType.value().equals(javaClass)) { final TypescriptField field = new TypescriptField(typeInfoAnnotation.property(), new TypescriptStringConstantType(subType.name()), TypescriptField.MANDATORY); iface.field(field); } } }
private String getJsonType(Class<?> clazz, JsonTypeInfo typeInfo) { String value; JsonTypeInfo.Id use = typeInfo.use(); switch (use) { case CLASS: value = clazz.getName(); break; case NAME: { JsonSubTypes.Type needed = null; JsonSubTypes subTypes = AnnotationUtils.findAnnotation(clazz, JsonSubTypes.class); if(subTypes != null) { for(JsonSubTypes.Type type: subTypes.value()) { if(type.value().equals(clazz)) { needed = type; break; } } } if(needed == null) { throw new IllegalArgumentException("On " + clazz + " can not find 'JsonSubTypes' record for current type."); } value = needed.name(); break; } default: throw new IllegalArgumentException("On " + clazz + " find unexpected 'JsonTypeInfo.use' value: " + use); } return value; }
private String getTypeName(JsonTypeInfo parentJsonTypeInfo, final Class<?> cls) { // Id.CLASS if (parentJsonTypeInfo.use() == JsonTypeInfo.Id.CLASS) { return cls.getName(); } // find @JsonTypeName recursively final JsonTypeName jsonTypeName = getAnnotationRecursive(cls, JsonTypeName.class); if (jsonTypeName != null && !jsonTypeName.value().isEmpty()) { return jsonTypeName.value(); } // find @JsonSubTypes.Type recursively final JsonSubTypes jsonSubTypes = getAnnotationRecursive(cls, JsonSubTypes.class, new Predicate<JsonSubTypes>() { @Override public boolean test(JsonSubTypes types) { return getJsonSubTypeForClass(types, cls) != null; } }); if (jsonSubTypes != null) { final JsonSubTypes.Type jsonSubType = getJsonSubTypeForClass(jsonSubTypes, cls); if (!jsonSubType.name().isEmpty()) { return jsonSubType.name(); } } // use simplified class name if it's not an interface or abstract if(!cls.isInterface() && !Modifier.isAbstract(cls.getModifiers())) { return cls.getName().substring(cls.getName().lastIndexOf(".") + 1); } return null; }
@Override public Class<?> call() throws Exception { return element.value(); } }, type.getContext().getContext().getProcessingEnvironment());
@Override public Class<?> call() throws Exception { return element.value(); } }, this.env);
@Override public Class<?> call() throws Exception { return element.value(); } }, type.getContext().getContext().getProcessingEnvironment());
@JsonSubTypes.Type(value = StrokeFilter.class) public class StrokeFilter extends Filter { /** * */ private static final long serialVersionUID = 2027201370278979033L; @Override public String toString() { String comp = getComparisonType().toString(); return comp + "_" + (getElements().contains("") ? "ANY" : String.join(",", getElements())); } }
@Override public Class<?> call() throws Exception { return element.value(); } }, this.env);
protected List<Subtype> getPossibleTypesForClass(GeneratorContext context, JClassType classType, Id id, boolean isLeaf, TreeLogger logger, Collection<JsonSubTypes.Type> types) throws UnableToCompleteException { List<Subtype> possibleTypes = Lists.newArrayList(); List<JClassType> resolvedSubtypes = Lists.newArrayList(); if (types != null && !types.isEmpty()) { for (JsonSubTypes.Type type : types) { JClassType typeClass = BaseSourceCreator.find(type.value(), logger, context); if (!isLeaf || classType.equals(typeClass)) { resolvedSubtypes.add(typeClass); } } } else { for (JClassType typeClass : context.getTypeOracle().getTypes()) { if (!typeClass.isAbstract() && typeClass.isAssignableTo(classType)) { resolvedSubtypes.add(typeClass); } } } for (JClassType typeClass : resolvedSubtypes) { possibleTypes.add( new Subtype(id == Id.CLASS ? typeClass.getQualifiedSourceName() : "." + typeClass.getSimpleSourceName(), typeClass)); } return possibleTypes; }
protected List<Subtype> getPossibleTypesForClass(GeneratorContext context, JClassType classType, Id id, boolean isLeaf, TreeLogger logger, Collection<JsonSubTypes.Type> types) throws UnableToCompleteException { List<Subtype> possibleTypes = Lists.newArrayList(); List<JClassType> resolvedSubtypes = Lists.newArrayList(); if (types != null && !types.isEmpty()) { for (JsonSubTypes.Type type : types) { JClassType typeClass = BaseSourceCreator.find(type.value(), logger, context); if (!isLeaf || classType.equals(typeClass)) { resolvedSubtypes.add(typeClass); } } } else { for (JClassType typeClass : context.getTypeOracle().getTypes()) { if (!typeClass.isAbstract() && typeClass.isAssignableTo(classType)) { resolvedSubtypes.add(typeClass); } } } for (JClassType typeClass : resolvedSubtypes) { possibleTypes.add( new Subtype(id == Id.CLASS ? typeClass.getQualifiedSourceName() : "." + typeClass.getSimpleSourceName(), typeClass)); } return possibleTypes; }
private static String findNameOnJsonSubTypes( JClassType baseType, JClassType subtype, ImmutableList<JClassType> allSubtypes, Optional<JsonSubTypes> propertySubTypes, Optional<JsonSubTypes> baseSubTypes ) { JsonSubTypes.Type typeFound = findTypeOnSubTypes( subtype, propertySubTypes ); if ( null != typeFound ) { return typeFound.name(); } typeFound = findTypeOnSubTypes( subtype, baseSubTypes ); if ( null != typeFound ) { return typeFound.name(); } if ( baseType != subtype ) { // we look in all the hierarchy JClassType type = subtype; while ( null != type ) { if ( allSubtypes.contains( type ) ) { JsonSubTypes.Type found = findTypeOnSubTypes( subtype, Optional.fromNullable( type .getAnnotation( JsonSubTypes.class ) ) ); if ( null != found ) { typeFound = found; } } type = type.getSuperclass(); } if ( null != typeFound ) { return typeFound.name(); } } return null; }
if (type.name() != null && !type.name().isEmpty()) { JClassType typeClass = BaseSourceCreator.find(type.value(), logger, context); if (!isLeaf || classType.equals(typeClass)) { possibleTypes.add(new Subtype(type.name(), typeClass)); JsonTypeName nameAnnotation = type.value().getAnnotation(JsonTypeName.class); if (nameAnnotation == null || nameAnnotation.value() == null || nameAnnotation.value().isEmpty()) { logger.log(BaseSourceCreator.ERROR, "Cannot find @JsonTypeName annotation for type: " + type.value()); throw new UnableToCompleteException(); JClassType typeClass = BaseSourceCreator.find(type.value(), logger, context); if (!isLeaf || classType.equals(typeClass)) { possibleTypes.add(new Subtype(nameAnnotation.value(), typeClass));
if (type.name() != null && !type.name().isEmpty()) { JClassType typeClass = BaseSourceCreator.find(type.value(), logger, context); if (!isLeaf || classType.equals(typeClass)) { possibleTypes.add(new Subtype(type.name(), typeClass)); JsonTypeName nameAnnotation = type.value().getAnnotation(JsonTypeName.class); if (nameAnnotation == null || nameAnnotation.value() == null || nameAnnotation.value().isEmpty()) { logger.log(BaseSourceCreator.ERROR, "Cannot find @JsonTypeName annotation for type: " + type.value()); throw new UnableToCompleteException(); JClassType typeClass = BaseSourceCreator.find(type.value(), logger, context); if (!isLeaf || classType.equals(typeClass)) { possibleTypes.add(new Subtype(nameAnnotation.value(), typeClass));
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type", visible = true) @JsonSubTypes({ @Type(value = MappingAttributePathInstance.class, name = "MappingAttributePathInstance") }) @XmlRootElement @Entity @ManyToOne(fetch = FetchType.LAZY, cascade = { CascadeType.DETACH, CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH }) @JoinColumn(name = "ATTRIBUTE_PATH") @JsonInclude(JsonInclude.Include.NON_NULL) private AttributePath attributePath;
JsonTypeInfo typeInfo = getAnnotation(JsonTypeInfo.class); if (typeInfo != null) { typeIdInclusion = typeInfo.include(); typeIdProperty = typeInfo.property(); if ("".equals(typeIdProperty)) { typeIdProperty = null; XmlElementRefs xmlElementRefs = getAnnotation(XmlElementRefs.class); if (subTypes != null && subTypes.value().length > 0) { for (final JsonSubTypes.Type element : subTypes.value()) { DecoratedTypeMirror choiceType = Annotations.mirrorOf(new Callable<Class<?>>() { @Override String choiceTypeId = element.name(); if ("".equals(choiceTypeId)) { if ((choiceTypeId == null || "".equals(choiceTypeId)) && choiceTypeInfo != null && choiceTypeInfo.use() == JsonTypeInfo.Id.CLASS) { choiceTypeId = choiceElement.getQualifiedName().toString();
@JsonTypeInfo( use = JsonTypeInfo.Id.NAME, property = "type") @JsonSubTypes({ @Type(value = CodeGroup.class, name = CodeGroup.TYPE), @Type(value = MembersGroup.class, name = MembersGroup.TYPE) }) public abstract class Group implements Serializable, Cloneable { @JsonInclude(Include.NON_NULL) public String id; @JsonInclude(Include.NON_DEFAULT) public LocalizedString title = LocalizedString.empty; @JsonInclude(Include.NON_DEFAULT) public LocalizedString description = LocalizedString.empty;