Examples with JsonTypeInfo org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonTypeInfo used on opensource projects

Example 6 with JsonTypeInfo

use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonTypeInfo in project Gaffer by gchq.

the class GenericInput method _setJsonInput.

@JsonTypeInfo(use = Id.NONE)
@JsonSetter("input")
void _setJsonInput(final I input) throws SerialisationException {
    // Sometimes json type info is stored in an array of size 2.
    // In that case we cannot determine if the input is multi or not.
    boolean isSingular = true;
    if (input instanceof Object[]) {
        isSingular = ((Object[]) input).length == 2 && ((Object[]) input)[0] instanceof String;
    } else if (input instanceof Collection) {
        isSingular = ((Collection) input).size() == 2 && ((Collection) input).iterator().next() instanceof String;
    } else if (input instanceof Iterable) {
        // A bit messy but it is efficient. Only iterators over enough to decide if the length is 2.
        final Iterator itr = ((Iterable) input).iterator();
        try {
            if (itr.hasNext()) {
                final Object firstItem = itr.next();
                if (firstItem instanceof String && itr.hasNext()) {
                    itr.next();
                    isSingular = !itr.hasNext();
                }
            }
        } finally {
            // Try to close the iterator just in case it is closeable.
            CloseableUtil.close(itr);
        }
    }
    final byte[] wrapperJson = JSONSerialiser.serialise(new InputWrapperNoTypeInfo(input));
    Object resultInput = input;
    if (isSingular) {
        try {
            resultInput = JSONSerialiser.deserialise(wrapperJson, InputWrapper.class).getInput();
        } catch (final SerialisationException e) {
            // Try assuming it is an multi input
            isSingular = false;
        }
    }
    if (!isSingular) {
        try {
            resultInput = JSONSerialiser.deserialise(wrapperJson, MultiInputWrapper.class).getInputAsIterable();
        } catch (final SerialisationException e2) {
        // Just use the original input
        }
    }
    setInput((I) resultInput);
}

Example 7 with JsonTypeInfo

use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonTypeInfo in project swagger-core by swagger-api.

the class ModelResolver method resolve.

public Model resolve(JavaType type, ModelConverterContext context, Iterator<ModelConverter> next) {
    if (type.isEnumType() || PrimitiveType.fromType(type) != null) {
        // We don't build models for primitive types
        return null;
    }
    final BeanDescription beanDesc = _mapper.getSerializationConfig().introspect(type);
    // Couple of possibilities for defining
    String name = _typeName(type, beanDesc);
    if ("Object".equals(name)) {
        return new ModelImpl();
    }
    /**
         * --Preventing parent/child hierarchy creation loops - Comment 1--
         * Creating a parent model will result in the creation of child models. Creating a child model will result in
         * the creation of a parent model, as per the second If statement following this comment.
         *
         * By checking whether a model has already been resolved (as implemented below), loops of parents creating
         * children and children creating parents can be short-circuited. This works because currently the
         * ModelConverterContextImpl will return null for a class that already been processed, but has not yet been
         * defined. This logic works in conjunction with the early immediate definition of model in the context
         * implemented later in this method (See "Preventing parent/child hierarchy creation loops - Comment 2") to
         * prevent such
         */
    Model resolvedModel = context.resolve(type.getRawClass());
    if (resolvedModel != null) {
        if (!(resolvedModel instanceof ModelImpl || resolvedModel instanceof ComposedModel) || (resolvedModel instanceof ModelImpl && ((ModelImpl) resolvedModel).getName().equals(name))) {
            return resolvedModel;
        } else if (resolvedModel instanceof ComposedModel) {
            Model childModel = ((ComposedModel) resolvedModel).getChild();
            if (childModel != null && (!(childModel instanceof ModelImpl) || ((ModelImpl) childModel).getName().equals(name))) {
                return resolvedModel;
            }
        }
    }
    final ModelImpl model = new ModelImpl().type(ModelImpl.OBJECT).name(name).description(_description(beanDesc.getClassInfo()));
    if (!type.isContainerType()) {
        // define the model here to support self/cyclic referencing of models
        context.defineModel(name, model, type, null);
    }
    if (type.isContainerType()) {
        // We treat collections as primitive types, just need to add models for values (if any)
        context.resolve(type.getContentType());
        return null;
    }
    // if XmlRootElement annotation, construct an Xml object and attach it to the model
    XmlRootElement rootAnnotation = beanDesc.getClassAnnotations().get(XmlRootElement.class);
    if (rootAnnotation != null && !"".equals(rootAnnotation.name()) && !"##default".equals(rootAnnotation.name())) {
        LOGGER.debug("{}", rootAnnotation);
        Xml xml = new Xml().name(rootAnnotation.name());
        if (rootAnnotation.namespace() != null && !"".equals(rootAnnotation.namespace()) && !"##default".equals(rootAnnotation.namespace())) {
            xml.namespace(rootAnnotation.namespace());
        }
        model.xml(xml);
    }
    final XmlAccessorType xmlAccessorTypeAnnotation = beanDesc.getClassAnnotations().get(XmlAccessorType.class);
    // see if @JsonIgnoreProperties exist
    Set<String> propertiesToIgnore = new HashSet<String>();
    JsonIgnoreProperties ignoreProperties = beanDesc.getClassAnnotations().get(JsonIgnoreProperties.class);
    if (ignoreProperties != null) {
        propertiesToIgnore.addAll(Arrays.asList(ignoreProperties.value()));
    }
    final ApiModel apiModel = beanDesc.getClassAnnotations().get(ApiModel.class);
    String disc = (apiModel == null) ? "" : apiModel.discriminator();
    if (apiModel != null && StringUtils.isNotEmpty(apiModel.reference())) {
        model.setReference(apiModel.reference());
    }
    if (disc.isEmpty()) {
        // longer method would involve AnnotationIntrospector.findTypeResolver(...) but:
        JsonTypeInfo typeInfo = beanDesc.getClassAnnotations().get(JsonTypeInfo.class);
        if (typeInfo != null) {
            disc = typeInfo.property();
        }
    }
    if (!disc.isEmpty()) {
        model.setDiscriminator(disc);
    }
    List<Property> props = new ArrayList<Property>();
    for (BeanPropertyDefinition propDef : beanDesc.findProperties()) {
        Property property = null;
        String propName = propDef.getName();
        Annotation[] annotations = null;
        // it's ugly but gets around https://github.com/swagger-api/swagger-core/issues/415
        if (propDef.getPrimaryMember() != null) {
            java.lang.reflect.Member member = propDef.getPrimaryMember().getMember();
            if (member != null) {
                String altName = member.getName();
                if (altName != null) {
                    final int length = altName.length();
                    for (String prefix : Arrays.asList("get", "is")) {
                        final int offset = prefix.length();
                        if (altName.startsWith(prefix) && length > offset && !Character.isUpperCase(altName.charAt(offset))) {
                            propName = altName;
                            break;
                        }
                    }
                }
            }
        }
        PropertyMetadata md = propDef.getMetadata();
        boolean hasSetter = false, hasGetter = false;
        try {
            if (propDef.getSetter() == null) {
                hasSetter = false;
            } else {
                hasSetter = true;
            }
        } catch (IllegalArgumentException e) {
            //com.fasterxml.jackson.databind.introspect.POJOPropertyBuilder would throw IllegalArgumentException
            // if there are overloaded setters. If we only want to know whether a set method exists, suppress the exception
            // is reasonable.
            // More logs might be added here
            hasSetter = true;
        }
        if (propDef.getGetter() != null) {
            JsonProperty pd = propDef.getGetter().getAnnotation(JsonProperty.class);
            if (pd != null) {
                hasGetter = true;
            }
        }
        Boolean isReadOnly = null;
        if (!hasSetter & hasGetter) {
            isReadOnly = Boolean.TRUE;
        } else {
            isReadOnly = Boolean.FALSE;
        }
        final AnnotatedMember member = propDef.getPrimaryMember();
        Boolean allowEmptyValue = null;
        if (member != null && !ignore(member, xmlAccessorTypeAnnotation, propName, propertiesToIgnore)) {
            List<Annotation> annotationList = new ArrayList<Annotation>();
            for (Annotation a : member.annotations()) {
                annotationList.add(a);
            }
            annotations = annotationList.toArray(new Annotation[annotationList.size()]);
            ApiModelProperty mp = member.getAnnotation(ApiModelProperty.class);
            if (mp != null && mp.readOnly()) {
                isReadOnly = mp.readOnly();
            }
            if (mp != null && mp.allowEmptyValue()) {
                allowEmptyValue = mp.allowEmptyValue();
            } else {
                allowEmptyValue = null;
            }
            JavaType propType = member.getType(beanDesc.bindingsForBeanType());
            // allow override of name from annotation
            if (mp != null && !mp.name().isEmpty()) {
                propName = mp.name();
            }
            if (mp != null && !mp.dataType().isEmpty()) {
                String or = mp.dataType();
                JavaType innerJavaType = null;
                LOGGER.debug("overriding datatype from {} to {}", propType, or);
                if (or.toLowerCase().startsWith("list[")) {
                    String innerType = or.substring(5, or.length() - 1);
                    ArrayProperty p = new ArrayProperty();
                    Property primitiveProperty = PrimitiveType.createProperty(innerType);
                    if (primitiveProperty != null) {
                        p.setItems(primitiveProperty);
                    } else {
                        innerJavaType = getInnerType(innerType);
                        p.setItems(context.resolveProperty(innerJavaType, annotations));
                    }
                    property = p;
                } else if (or.toLowerCase().startsWith("map[")) {
                    int pos = or.indexOf(",");
                    if (pos > 0) {
                        String innerType = or.substring(pos + 1, or.length() - 1);
                        MapProperty p = new MapProperty();
                        Property primitiveProperty = PrimitiveType.createProperty(innerType);
                        if (primitiveProperty != null) {
                            p.setAdditionalProperties(primitiveProperty);
                        } else {
                            innerJavaType = getInnerType(innerType);
                            p.setAdditionalProperties(context.resolveProperty(innerJavaType, annotations));
                        }
                        property = p;
                    }
                } else {
                    Property primitiveProperty = PrimitiveType.createProperty(or);
                    if (primitiveProperty != null) {
                        property = primitiveProperty;
                    } else {
                        innerJavaType = getInnerType(or);
                        property = context.resolveProperty(innerJavaType, annotations);
                    }
                }
                if (innerJavaType != null) {
                    context.resolve(innerJavaType);
                }
            }
            // no property from override, construct from propType
            if (property == null) {
                if (mp != null && StringUtils.isNotEmpty(mp.reference())) {
                    property = new RefProperty(mp.reference());
                } else if (member.getAnnotation(JsonIdentityInfo.class) != null) {
                    property = GeneratorWrapper.processJsonIdentity(propType, context, _mapper, member.getAnnotation(JsonIdentityInfo.class), member.getAnnotation(JsonIdentityReference.class));
                }
                if (property == null) {
                    JsonUnwrapped uw = member.getAnnotation(JsonUnwrapped.class);
                    if (uw != null && uw.enabled()) {
                        handleUnwrapped(props, context.resolve(propType), uw.prefix(), uw.suffix());
                    } else {
                        property = context.resolveProperty(propType, annotations);
                    }
                }
            }
            if (property != null) {
                property.setName(propName);
                if (mp != null && !mp.access().isEmpty()) {
                    property.setAccess(mp.access());
                }
                Boolean required = md.getRequired();
                if (required != null) {
                    property.setRequired(required);
                }
                String description = _intr.findPropertyDescription(member);
                if (description != null && !"".equals(description)) {
                    property.setDescription(description);
                }
                Integer index = _intr.findPropertyIndex(member);
                if (index != null) {
                    property.setPosition(index);
                }
                property.setDefault(_findDefaultValue(member));
                property.setExample(_findExampleValue(member));
                property.setReadOnly(_findReadOnly(member));
                if (allowEmptyValue != null) {
                    property.setAllowEmptyValue(allowEmptyValue);
                }
                if (property.getReadOnly() == null) {
                    if (isReadOnly) {
                        property.setReadOnly(isReadOnly);
                    }
                }
                if (mp != null) {
                    final AllowableValues allowableValues = AllowableValuesUtils.create(mp.allowableValues());
                    if (allowableValues != null) {
                        final Map<PropertyBuilder.PropertyId, Object> args = allowableValues.asPropertyArguments();
                        PropertyBuilder.merge(property, args);
                    }
                }
                JAXBAnnotationsHelper.apply(member, property);
                applyBeanValidatorAnnotations(property, annotations);
                props.add(property);
            }
        }
    }
    Collections.sort(props, getPropertyComparator());
    Map<String, Property> modelProps = new LinkedHashMap<String, Property>();
    for (Property prop : props) {
        modelProps.put(prop.getName(), prop);
    }
    model.setProperties(modelProps);
    /**
         * --Preventing parent/child hierarchy creation loops - Comment 2--
         * Creating a parent model will result in the creation of child models, as per the first If statement following
         * this comment. Creating a child model will result in the creation of a parent model, as per the second If
         * statement following this comment.
         *
         * The current model must be defined in the context immediately. This done to help prevent repeated
         * loops where  parents create children and children create parents when a hierarchy is present. This logic
         * works in conjunction with the "early checking" performed earlier in this method
         * (See "Preventing parent/child hierarchy creation loops - Comment 1"), to prevent repeated creation loops.
         *
         *
         * As an aside, defining the current model in the context immediately also ensures that child models are
         * available for modification by resolveSubtypes, when their parents are created.
         */
    Class<?> currentType = type.getRawClass();
    context.defineModel(name, model, currentType, null);
    /**
         * This must be done after model.setProperties so that the model's set
         * of properties is available to filter from any subtypes
         **/
    if (!resolveSubtypes(model, beanDesc, context)) {
        model.setDiscriminator(null);
    }
    if (apiModel != null) {
        /**
             * Check if the @ApiModel annotation has a parent property containing a value that should not be ignored
             */
        Class<?> parentClass = apiModel.parent();
        if (parentClass != null && !parentClass.equals(Void.class) && !this.shouldIgnoreClass(parentClass)) {
            JavaType parentType = _mapper.constructType(parentClass);
            final BeanDescription parentBeanDesc = _mapper.getSerializationConfig().introspect(parentType);
            /**
                 * Retrieve all the sub-types of the parent class and ensure that the current type is one of those types
                 */
            boolean currentTypeIsParentSubType = false;
            List<NamedType> subTypes = _intr.findSubtypes(parentBeanDesc.getClassInfo());
            if (subTypes != null) {
                for (NamedType subType : subTypes) {
                    if (subType.getType().equals(currentType)) {
                        currentTypeIsParentSubType = true;
                        break;
                    }
                }
            }
            /**
                 Retrieve the subTypes from the parent class @ApiModel annotation and ensure that the current type
                 is one of those types.
                 */
            boolean currentTypeIsParentApiModelSubType = false;
            final ApiModel parentApiModel = parentBeanDesc.getClassAnnotations().get(ApiModel.class);
            if (parentApiModel != null) {
                Class<?>[] apiModelSubTypes = parentApiModel.subTypes();
                if (apiModelSubTypes != null) {
                    for (Class<?> subType : apiModelSubTypes) {
                        if (subType.equals(currentType)) {
                            currentTypeIsParentApiModelSubType = true;
                            break;
                        }
                    }
                }
            }
            /**
                 If the current type is a sub-type of the parent class and is listed in the subTypes property of the
                 parent class @ApiModel annotation, then do the following:
                 1. Resolve the model for the parent class. This will result in the parent model being created, and the
                 current child model being updated to be a ComposedModel referencing the parent.
                 2. Resolve and return the current child type again. This will return the new ComposedModel from the
                 context, which was created in step 1 above. Admittedly, there is a small chance that this may result
                 in a stack overflow, if the context does not correctly cache the model for the current type. However,
                 as context caching is assumed elsewhere to avoid cyclical model creation, this was deemed to be
                 sufficient.
                 */
            if (currentTypeIsParentSubType && currentTypeIsParentApiModelSubType) {
                context.resolve(parentClass);
                return context.resolve(currentType);
            }
        }
    }
    return model;
}

Example 8 with JsonTypeInfo

use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonTypeInfo in project AJSC by att.

the class Unmarshaller method determineImplementationClass.

/**
 * This method checks the specified bean property to locate the implementation class to be used. If the
 * implementation class supports polymorphic mappings, then the implementation class is further inspected for
 * JsonTypeInfo annotations. If the annotation is present, then the annotation directs the processing. Because the
 * processing of the annotation may be data-dependent, the mapped data to be unmarshalled must be provided as well.
 *
 * @param beanProperty
 *            The bean property we are mapping the contents into
 * @param obj
 *            The object that contains the mappings
 * @return The class to be constructed to contain the mappings
 * @throws UnmarshallException
 *             If the json type info uses unsupported metadata determination
 */
@SuppressWarnings("unchecked")
private Class<? extends ModelObject> determineImplementationClass(BeanProperty beanProperty, Object obj) throws UnmarshallException {
    Class<? extends ModelObject> implClass = null;
    JsonTypeInfo typeInfo = null;
    JsonSubTypes subTypes = null;
    Class<?> defaultImplClass = null;
    /*
         * First, try to determine the implementation class to be created based on the bean property type. If the bean
         * property is a scalar type, then use it as is. If it is a list, then use the first generic type. If it is a
         * map, use the second generic type (maps are always assumed to be keyed by strings).
         */
    implClass = (Class<? extends ModelObject>) beanProperty.getPropertyType();
    if (beanProperty.isList()) {
        implClass = (Class<? extends ModelObject>) beanProperty.getCollectionTypes()[0];
    } else if (beanProperty.isMap()) {
        implClass = (Class<? extends ModelObject>) beanProperty.getCollectionTypes()[1];
    }
    /*
         * HACK: If the implClass is Constraint, then we have a special case. We need to examine the first key in the
         * map to determine the type of constraint and return that name.
         */
    if (implClass.equals(Constraint.class)) {
        if (obj instanceof List) {
            Map<String, Object> map = (Map<String, Object>) ((List<Object>) obj).get(0);
            String constraintType = (String) map.keySet().toArray()[0];
            for (int index = 0; index < CONSTRAINT_TYPES.length; index++) {
                if (CONSTRAINT_TYPES[index].equals(constraintType)) {
                    implClass = CONSTRAINT_CLASSES[index];
                    return implClass;
                }
            }
        }
    }
    /*
         * If typeInfo annotation is present on the property type class, then check it to get the actual implementation
         * class. Otherwise, we will instantiate the property defined.
         */
    typeInfo = (JsonTypeInfo) ObjectHelper.getClassAnnotation(implClass, JsonTypeInfo.class);
    if (typeInfo != null) {
        subTypes = (JsonSubTypes) ObjectHelper.getClassAnnotation(implClass, JsonSubTypes.class);
        defaultImplClass = typeInfo.defaultImpl();
        JsonTypeInfo.Id use = typeInfo.use();
        JsonTypeInfo.As include = typeInfo.include();
        if (use.equals(JsonTypeInfo.Id.NAME) && include.equals(JsonTypeInfo.As.PROPERTY)) {
            if (obj instanceof Map) {
                Map<String, Object> map = (Map<String, Object>) obj;
                String property = typeInfo.property();
                String propertyValue = (String) map.get(property);
                implClass = (Class<? extends ModelObject>) defaultImplClass;
                if (propertyValue != null) {
                    JsonSubTypes.Type[] types = subTypes.value();
                    for (JsonSubTypes.Type type : types) {
                        if (type.name().equals(propertyValue)) {
                            implClass = (Class<? extends ModelObject>) type.value();
                            break;
                        }
                    }
                }
            }
        } else if (use.equals(JsonTypeInfo.Id.CUSTOM)) {
            JsonDeserialize deserializeAnnotation = (JsonDeserialize) ObjectHelper.getClassAnnotation(implClass, JsonDeserialize.class);
            Class<? extends JsonDeserializer> deserializer = deserializeAnnotation.using();
        } else {
            throw new UnmarshallException(String.format("Only JsonTypeInfo use=\"NAME\" and include=\"PROPERTY\" " + " or use=\"CUSTOM\" with custom deserializer are supported.  The mapping specified " + "use=\"%s\" and include=\"%s\"", use.name(), include.name()));
        }
    }
    return implClass;
}

Example 9 with JsonTypeInfo

use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonTypeInfo in project swagger-core by swagger-api.

the class ModelResolver method resolveDiscriminatorProperty.

protected void resolveDiscriminatorProperty(JavaType type, ModelConverterContext context, Schema model) {
    // add JsonTypeInfo.property if not member of bean
    JsonTypeInfo typeInfo = type.getRawClass().getDeclaredAnnotation(JsonTypeInfo.class);
    if (typeInfo != null) {
        String typeInfoProp = typeInfo.property();
        if (StringUtils.isNotBlank(typeInfoProp)) {
            Schema modelToUpdate = model;
            if (StringUtils.isNotBlank(model.get$ref())) {
                modelToUpdate = context.getDefinedModels().get(model.get$ref().substring(21));
            }
            if (modelToUpdate.getProperties() == null || !modelToUpdate.getProperties().keySet().contains(typeInfoProp)) {
                Schema discriminatorSchema = new StringSchema().name(typeInfoProp);
                modelToUpdate.addProperties(typeInfoProp, discriminatorSchema);
                if (modelToUpdate.getRequired() == null || !modelToUpdate.getRequired().contains(typeInfoProp)) {
                    modelToUpdate.addRequiredItem(typeInfoProp);
                }
            }
        }
    }
}

Example 10 with JsonTypeInfo

use of org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonTypeInfo in project swagger-core by swagger-api.

the class ModelResolver method resolveWrapping.

/*
     TODO partial implementation supporting WRAPPER_OBJECT with JsonTypeInfo.Id.CLASS and JsonTypeInfo.Id.NAME

     Also note that JsonTypeInfo on interfaces are not considered as multiple interfaces might have conflicting
     annotations, although Jackson seems to apply them if present on an interface
     */
protected Schema resolveWrapping(JavaType type, ModelConverterContext context, Schema model) {
    // add JsonTypeInfo.property if not member of bean
    JsonTypeInfo typeInfo = type.getRawClass().getDeclaredAnnotation(JsonTypeInfo.class);
    if (typeInfo != null) {
        JsonTypeInfo.Id id = typeInfo.use();
        JsonTypeInfo.As as = typeInfo.include();
        if (JsonTypeInfo.As.WRAPPER_OBJECT.equals(as)) {
            String name = model.getName();
            if (JsonTypeInfo.Id.CLASS.equals(id)) {
                name = type.getRawClass().getName();
            }
            Schema wrapperSchema = new ObjectSchema();
            wrapperSchema.name(model.getName());
            wrapperSchema.addProperties(name, model);
            return wrapperSchema;
        }
    }
    return model;
}