Examples with XmlMimeType jakarta.xml.bind.annotation.XmlMimeType used on opensource projects

Example 1 with XmlMimeType

use of jakarta.xml.bind.annotation.XmlMimeType in project metro-jax-ws by eclipse-ee4j.

the class WrapperBeanGenerator method createBeanImage.

// Creates class's bytes
private static byte[] createBeanImage(String className, String rootName, String rootNS, String typeName, String typeNS, Collection<Field> fields) throws Exception {
    ClassWriter cw = new ClassWriter(0);
    // org.objectweb.asm.util.TraceClassVisitor cw = new org.objectweb.asm.util.TraceClassVisitor(actual, new java.io.PrintWriter(System.out));
    cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, replaceDotWithSlash(className), null, "java/lang/Object", null);
    AnnotationVisitor root = cw.visitAnnotation("Ljakarta/xml/bind/annotation/XmlRootElement;", true);
    root.visit("name", rootName);
    root.visit("namespace", rootNS);
    root.visitEnd();
    AnnotationVisitor type = cw.visitAnnotation("Ljakarta/xml/bind/annotation/XmlType;", true);
    type.visit("name", typeName);
    type.visit("namespace", typeNS);
    if (fields.size() > 1) {
        AnnotationVisitor propVisitor = type.visitArray("propOrder");
        for (Field field : fields) {
            propVisitor.visit("propOrder", field.fieldName);
        }
        propVisitor.visitEnd();
    }
    type.visitEnd();
    for (Field field : fields) {
        FieldVisitor fv = cw.visitField(Opcodes.ACC_PUBLIC, field.fieldName, field.asmType.getDescriptor(), field.getSignature(), null);
        for (Annotation ann : field.jaxbAnnotations) {
            if (ann instanceof XmlMimeType) {
                AnnotationVisitor mime = fv.visitAnnotation("Ljakarta/xml/bind/annotation/XmlMimeType;", true);
                mime.visit("value", ((XmlMimeType) ann).value());
                mime.visitEnd();
            } else if (ann instanceof XmlJavaTypeAdapter) {
                AnnotationVisitor ada = fv.visitAnnotation("Ljakarta/xml/bind/annotation/adapters/XmlJavaTypeAdapter;", true);
                ada.visit("value", getASMType(((XmlJavaTypeAdapter) ann).value()));
                // XmlJavaTypeAdapter.type() is for package only. No need to copy.
                // ada.visit("type", ((XmlJavaTypeAdapter)ann).type());
                ada.visitEnd();
            } else if (ann instanceof XmlAttachmentRef) {
                AnnotationVisitor att = fv.visitAnnotation("Ljakarta/xml/bind/annotation/XmlAttachmentRef;", true);
                att.visitEnd();
            } else if (ann instanceof XmlList) {
                AnnotationVisitor list = fv.visitAnnotation("Ljakarta/xml/bind/annotation/XmlList;", true);
                list.visitEnd();
            } else if (ann instanceof XmlElement) {
                AnnotationVisitor elem = fv.visitAnnotation("Ljakarta/xml/bind/annotation/XmlElement;", true);
                XmlElement xmlElem = (XmlElement) ann;
                elem.visit("name", xmlElem.name());
                elem.visit("namespace", xmlElem.namespace());
                if (xmlElem.nillable()) {
                    elem.visit("nillable", true);
                }
                if (xmlElem.required()) {
                    elem.visit("required", true);
                }
                elem.visitEnd();
            } else {
                throw new WebServiceException("Unknown JAXB annotation " + ann);
            }
        }
        fv.visitEnd();
    }
    MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
    mv.visitCode();
    mv.visitVarInsn(Opcodes.ALOAD, 0);
    mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
    mv.visitInsn(Opcodes.RETURN);
    mv.visitMaxs(1, 1);
    mv.visitEnd();
    cw.visitEnd();
    if (LOGGER.isLoggable(Level.FINE)) {
        // Class's @XmlRootElement
        StringBuilder sb = new StringBuilder();
        sb.append("\n");
        sb.append("@XmlRootElement(name=").append(rootName).append(", namespace=").append(rootNS).append(")");
        // Class's @XmlType
        sb.append("\n");
        sb.append("@XmlType(name=").append(typeName).append(", namespace=").append(typeNS);
        if (fields.size() > 1) {
            sb.append(", propOrder={");
            for (Field field : fields) {
                sb.append(" ");
                sb.append(field.fieldName);
            }
            sb.append(" }");
        }
        sb.append(")");
        // class declaration
        sb.append("\n");
        sb.append("public class ").append(className).append(" {");
        // fields declaration
        for (Field field : fields) {
            sb.append("\n");
            // Field's other JAXB annotations
            for (Annotation ann : field.jaxbAnnotations) {
                sb.append("\n    ");
                if (ann instanceof XmlMimeType) {
                    sb.append("@XmlMimeType(value=").append(((XmlMimeType) ann).value()).append(")");
                } else if (ann instanceof XmlJavaTypeAdapter) {
                    sb.append("@XmlJavaTypeAdapter(value=").append(getASMType(((XmlJavaTypeAdapter) ann).value())).append(")");
                } else if (ann instanceof XmlAttachmentRef) {
                    sb.append("@XmlAttachmentRef");
                } else if (ann instanceof XmlList) {
                    sb.append("@XmlList");
                } else if (ann instanceof XmlElement) {
                    XmlElement xmlElem = (XmlElement) ann;
                    sb.append("\n    ");
                    sb.append("@XmlElement(name=").append(xmlElem.name()).append(", namespace=").append(xmlElem.namespace());
                    if (xmlElem.nillable()) {
                        sb.append(", nillable=true");
                    }
                    if (xmlElem.required()) {
                        sb.append(", required=true");
                    }
                    sb.append(")");
                } else {
                    throw new WebServiceException("Unknown JAXB annotation " + ann);
                }
            }
            // Field declaration
            sb.append("\n    ");
            sb.append("public ");
            if (field.getSignature() == null) {
                sb.append(field.asmType.getDescriptor());
            } else {
                sb.append(field.getSignature());
            }
            sb.append(" ");
            sb.append(field.fieldName);
        }
        sb.append("\n\n}");
        LOGGER.fine(sb.toString());
    }
    return cw.toByteArray();
}

Example 2 with XmlMimeType

use of jakarta.xml.bind.annotation.XmlMimeType in project metro-jax-ws by eclipse-ee4j.

the class WebServiceWrapperGenerator method annotateParameterWithJaxbAnnotations.

private void annotateParameterWithJaxbAnnotations(MemberInfo memInfo, JFieldVar field) {
    List<Annotation> jaxbAnnotations = memInfo.getJaxbAnnotations();
    for (Annotation ann : jaxbAnnotations) {
        if (ann instanceof XmlMimeType) {
            JAnnotationUse jaxbAnn = field.annotate(XmlMimeType.class);
            jaxbAnn.param("value", ((XmlMimeType) ann).value());
        } else if (ann instanceof XmlJavaTypeAdapter) {
            JAnnotationUse jaxbAnn = field.annotate(XmlJavaTypeAdapter.class);
            XmlJavaTypeAdapter ja = (XmlJavaTypeAdapter) ann;
            try {
                ja.value();
                throw new AssertionError();
            } catch (MirroredTypeException e) {
                jaxbAnn.param("value", getType(e.getTypeMirror()));
            }
        // XmlJavaTypeAdapter.type() is for package only. No need to copy.
        } else if (ann instanceof XmlAttachmentRef) {
            field.annotate(XmlAttachmentRef.class);
        } else if (ann instanceof XmlList) {
            field.annotate(XmlList.class);
        } else if (ann instanceof XmlElement) {
            XmlElement elemAnn = (XmlElement) ann;
            JAnnotationUse jAnn = field.annotate(XmlElement.class);
            jAnn.param("name", elemAnn.name());
            jAnn.param("namespace", elemAnn.namespace());
            if (elemAnn.nillable()) {
                jAnn.param("nillable", true);
            }
            if (elemAnn.required()) {
                jAnn.param("required", true);
            }
        } else {
            throw new WebServiceException("SEI Parameter cannot have this JAXB annotation: " + ann);
        }
    }
}

Example 3 with XmlMimeType

use of jakarta.xml.bind.annotation.XmlMimeType in project eclipselink by eclipse-ee4j.

the class AnnotationsProcessor method processXmlElementDecl.

private JavaClass processXmlElementDecl(JavaClass type, JavaMethod next, PackageInfo packageInfo, Map<String, org.eclipse.persistence.jaxb.xmlmodel.XmlRegistry.XmlElementDecl> elemDecls) {
    JavaClass returnType = type;
    // if there's an XmlElementDecl for this method from XML, use it
    // - otherwise look for an annotation
    org.eclipse.persistence.jaxb.xmlmodel.XmlRegistry.XmlElementDecl xmlEltDecl = elemDecls.get(next.getName());
    if ((xmlEltDecl != null) || helper.isAnnotationPresent(next, XmlElementDecl.class)) {
        QName qname;
        QName substitutionHead = null;
        String url;
        String localName;
        String defaultValue = null;
        Class<?> scopeClass = jakarta.xml.bind.annotation.XmlElementDecl.GLOBAL.class;
        if (xmlEltDecl != null) {
            url = xmlEltDecl.getNamespace();
            localName = xmlEltDecl.getName();
            String scopeClassName = xmlEltDecl.getScope();
            if (!scopeClassName.equals(ELEMENT_DECL_GLOBAL)) {
                JavaClass jScopeClass = helper.getJavaClass(scopeClassName);
                if (jScopeClass != null) {
                    scopeClass = helper.getClassForJavaClass(jScopeClass);
                    if (scopeClass == null) {
                        scopeClass = jakarta.xml.bind.annotation.XmlElementDecl.GLOBAL.class;
                    }
                }
            }
            if (!xmlEltDecl.getSubstitutionHeadName().equals(EMPTY_STRING)) {
                String subHeadLocal = xmlEltDecl.getSubstitutionHeadName();
                String subHeadNamespace = xmlEltDecl.getSubstitutionHeadNamespace();
                if (subHeadNamespace.equals(XMLProcessor.DEFAULT)) {
                    subHeadNamespace = packageInfo.getNamespace();
                }
                substitutionHead = new QName(subHeadNamespace, subHeadLocal);
            }
            if (!(xmlEltDecl.getDefaultValue().length() == 1 && xmlEltDecl.getDefaultValue().startsWith(ELEMENT_DECL_DEFAULT))) {
                defaultValue = xmlEltDecl.getDefaultValue();
            }
        } else {
            // there was no xml-element-decl for this method in XML,
            // so use the annotation
            XmlElementDecl elementDecl = (XmlElementDecl) helper.getAnnotation(next, XmlElementDecl.class);
            url = elementDecl.namespace();
            localName = elementDecl.name();
            scopeClass = elementDecl.scope();
            if (!elementDecl.substitutionHeadName().equals(EMPTY_STRING)) {
                String subHeadLocal = elementDecl.substitutionHeadName();
                String subHeadNamespace = elementDecl.substitutionHeadNamespace();
                if (subHeadNamespace.equals(XMLProcessor.DEFAULT)) {
                    subHeadNamespace = packageInfo.getNamespace();
                }
                substitutionHead = new QName(subHeadNamespace, subHeadLocal);
            }
            if (!(elementDecl.defaultValue().length() == 1 && elementDecl.defaultValue().startsWith(ELEMENT_DECL_DEFAULT))) {
                defaultValue = elementDecl.defaultValue();
            }
        }
        if (XMLProcessor.DEFAULT.equals(url)) {
            url = packageInfo.getNamespace();
        }
        if (Constants.EMPTY_STRING.equals(url)) {
            isDefaultNamespaceAllowed = false;
            qname = new QName(localName);
        } else {
            qname = new QName(url, localName);
        }
        boolean isList = false;
        if (JAVA_UTIL_LIST.equals(type.getName())) {
            isList = true;
            Collection args = type.getActualTypeArguments();
            if (args.size() > 0) {
                type = (JavaClass) args.iterator().next();
            }
        }
        ElementDeclaration declaration = new ElementDeclaration(qname, type, type.getQualifiedName(), isList, scopeClass);
        if (substitutionHead != null) {
            declaration.setSubstitutionHead(substitutionHead);
        }
        if (defaultValue != null) {
            declaration.setDefaultValue(defaultValue);
        }
        if (helper.isAnnotationPresent(next, XmlJavaTypeAdapter.class)) {
            XmlJavaTypeAdapter typeAdapter = (XmlJavaTypeAdapter) helper.getAnnotation(next, XmlJavaTypeAdapter.class);
            Class<? extends XmlAdapter> typeAdapterClass = typeAdapter.value();
            declaration.setJavaTypeAdapterClass(typeAdapterClass);
            Class<?> declJavaType = CompilerHelper.getTypeFromAdapterClass(typeAdapterClass);
            JavaClass adaptedType = helper.getJavaClass(declJavaType);
            declaration.setJavaType(adaptedType);
            declaration.setAdaptedJavaType(type);
            returnType = adaptedType;
        }
        if (helper.isAnnotationPresent(next, XmlMimeType.class)) {
            XmlMimeType mimeType = (XmlMimeType) helper.getAnnotation(next, XmlMimeType.class);
            declaration.setXmlMimeType(mimeType.value());
        }
        if (helper.isAnnotationPresent(next, XmlAttachmentRef.class)) {
            declaration.setXmlAttachmentRef(true);
        }
        Map<QName, ElementDeclaration> elements = getElementDeclarationsForScope(scopeClass.getName());
        if (elements == null) {
            elements = new HashMap<>();
            this.elementDeclarations.put(scopeClass.getName(), elements);
        }
        if (elements.containsKey(qname)) {
            throw JAXBException.duplicateElementName(qname);
        }
        elements.put(qname, declaration);
    }
    return returnType;
}

Example 4 with XmlMimeType

use of jakarta.xml.bind.annotation.XmlMimeType in project eclipselink by eclipse-ee4j.

the class AnnotationsProcessor method createElementsForTypeMappingInfo.

public void createElementsForTypeMappingInfo() {
    if (javaClassToTypeMappingInfos != null && !javaClassToTypeMappingInfos.isEmpty()) {
        Set<JavaClass> classes = this.javaClassToTypeMappingInfos.keySet();
        for (JavaClass nextClass : classes) {
            List<TypeMappingInfo> nextInfos = this.javaClassToTypeMappingInfos.get(nextClass);
            for (TypeMappingInfo nextInfo : nextInfos) {
                if (nextInfo != null) {
                    boolean xmlAttachmentRef = false;
                    String xmlMimeType = null;
                    java.lang.annotation.Annotation[] annotations = getAnnotations(nextInfo);
                    Class<?> adapterClass = typeMappingInfoToAdapterClasses.get(nextInfo);
                    Class<?> declJavaType = null;
                    if (adapterClass != null) {
                        declJavaType = CompilerHelper.getTypeFromAdapterClass(adapterClass);
                    }
                    if (annotations != null) {
                        for (Annotation nextAnnotation : annotations) {
                            if (nextAnnotation != null) {
                                if (nextAnnotation instanceof XmlMimeType) {
                                    XmlMimeType javaAnnotation = (XmlMimeType) nextAnnotation;
                                    xmlMimeType = javaAnnotation.value();
                                } else if (nextAnnotation instanceof XmlAttachmentRef) {
                                    xmlAttachmentRef = true;
                                    if (!this.hasSwaRef) {
                                        this.hasSwaRef = true;
                                    }
                                }
                            }
                        }
                    }
                    QName qname;
                    String nextClassName = nextClass.getQualifiedName();
                    if (declJavaType != null) {
                        nextClassName = declJavaType.getCanonicalName();
                    }
                    if (typeMappingInfosToGeneratedClasses != null) {
                        Class<?> generatedClass = typeMappingInfosToGeneratedClasses.get(nextInfo);
                        if (generatedClass != null) {
                            nextClassName = generatedClass.getCanonicalName();
                        }
                    }
                    TypeInfo nextTypeInfo = typeInfos.get(nextClassName);
                    if (nextTypeInfo != null) {
                        qname = new QName(nextTypeInfo.getClassNamespace(), nextTypeInfo.getSchemaTypeName());
                    } else {
                        qname = getUserDefinedSchemaTypes().get(nextClassName);
                        if (qname == null) {
                            if (nextClassName.equals(ClassConstants.APBYTE.getName()) || nextClassName.equals(Image.class.getName()) || nextClassName.equals(Source.class.getName()) || nextClassName.equals("jakarta.activation.DataHandler")) {
                                if (xmlAttachmentRef) {
                                    qname = Constants.SWA_REF_QNAME;
                                } else {
                                    qname = Constants.BASE_64_BINARY_QNAME;
                                }
                            } else if (nextClassName.equals(ClassConstants.OBJECT.getName())) {
                                qname = Constants.ANY_TYPE_QNAME;
                            } else if (nextClassName.equals(ClassConstants.XML_GREGORIAN_CALENDAR.getName())) {
                                qname = Constants.ANY_SIMPLE_TYPE_QNAME;
                            } else {
                                Class<?> theClass = helper.getClassForJavaClass(nextClass);
                                qname = XMLConversionManager.getDefaultJavaTypes().get(theClass);
                            }
                        }
                    }
                    if (qname != null) {
                        typeMappingInfosToSchemaTypes.put(nextInfo, qname);
                    }
                    if (nextInfo.getXmlTagName() != null) {
                        ElementDeclaration element = new ElementDeclaration(nextInfo.getXmlTagName(), nextClass, nextClass.getQualifiedName(), false);
                        element.setTypeMappingInfo(nextInfo);
                        element.setXmlMimeType(xmlMimeType);
                        element.setXmlAttachmentRef(xmlAttachmentRef);
                        element.setNillable(nextInfo.isNillable());
                        if (declJavaType != null) {
                            element.setJavaType(helper.getJavaClass(declJavaType));
                        }
                        Class<?> generatedClass = typeMappingInfosToGeneratedClasses.get(nextInfo);
                        if (generatedClass != null) {
                            element.setJavaType(helper.getJavaClass(generatedClass));
                        }
                        if (nextInfo.getElementScope() == TypeMappingInfo.ElementScope.Global) {
                            ElementDeclaration currentElement = this.getGlobalElements().get(element.getElementName());
                            if (currentElement == null) {
                                addGlobalElement(element.getElementName(), element);
                            } else {
                                // if(currentElement.getTypeMappingInfo() == null) {
                                // the global element that exists came from an annotation
                                // } else {
                                this.localElements.add(element);
                            // }
                            }
                        } else {
                            this.localElements.add(element);
                        }
                        String rootNamespace = element.getElementName().getNamespaceURI();
                        if (rootNamespace == null) {
                            rootNamespace = Constants.EMPTY_STRING;
                        }
                        if (rootNamespace.equals(Constants.EMPTY_STRING)) {
                            isDefaultNamespaceAllowed = false;
                        }
                    }
                }
            }
        }
    }
}

Example 5 with XmlMimeType

use of jakarta.xml.bind.annotation.XmlMimeType in project eclipselink by eclipse-ee4j.

the class AnnotationsProcessor method getAnnotations.

/**
 * Returns an array of Annotations for a given TypeMappingInfo. This array
 * will either be populated from the TypeMappingInfo's array of annotations,
 * or based on an xml-element if present. The xml-element will take
 * precedence over the annotation array; if there is an xml-element the
 * Array of Annotations will be ignored.
 */
private java.lang.annotation.Annotation[] getAnnotations(TypeMappingInfo tmInfo) {
    if (tmInfo.getXmlElement() != null) {
        ClassLoader loader = helper.getClassLoader();
        // create a single ConversionManager for that will be shared by the
        // proxy objects
        ConversionManager cMgr = new ConversionManager();
        cMgr.setLoader(loader);
        // unmarshal the node into an XmlElement
        org.eclipse.persistence.jaxb.xmlmodel.XmlElement xElt = CompilerHelper.getXmlElement(tmInfo.getXmlElement(), loader);
        List<Annotation> annotations = new ArrayList<>();
        // where applicable, a given dynamic proxy will contain a Map of
        // method name/return value entries
        Map<String, Object> components = null;
        // handle @XmlElement: set 'type' method
        if (!(xElt.getType().equals("jakarta.xml.bind.annotation.XmlElement.DEFAULT"))) {
            components = new HashMap<>();
            components.put(TYPE_METHOD_NAME, xElt.getType());
            annotations.add(AnnotationProxy.getProxy(components, XmlElement.class, loader, cMgr));
        }
        // handle @XmlList
        if (xElt.isXmlList()) {
            annotations.add(AnnotationProxy.getProxy(components, XmlList.class, loader, cMgr));
        }
        // handle @XmlAttachmentRef
        if (xElt.isXmlAttachmentRef()) {
            annotations.add(AnnotationProxy.getProxy(components, XmlAttachmentRef.class, loader, cMgr));
        }
        // handle @XmlMimeType: set 'value' method
        if (xElt.getXmlMimeType() != null) {
            components = new HashMap<>();
            components.put(VALUE_METHOD_NAME, xElt.getXmlMimeType());
            annotations.add(AnnotationProxy.getProxy(components, XmlMimeType.class, loader, cMgr));
        }
        // handle @XmlJavaTypeAdapter: set 'type' and 'value' methods
        if (xElt.getXmlJavaTypeAdapter() != null) {
            components = new HashMap<>();
            components.put(TYPE_METHOD_NAME, xElt.getXmlJavaTypeAdapter().getType());
            components.put(VALUE_METHOD_NAME, xElt.getXmlJavaTypeAdapter().getValue());
            annotations.add(AnnotationProxy.getProxy(components, XmlJavaTypeAdapter.class, loader, cMgr));
        }
        // return the newly created array of dynamic proxy objects
        return annotations.toArray(new Annotation[annotations.size()]);
    }
    // array of Annotation objects
    return tmInfo.getAnnotations();
}