Examples with AltAnnotation org.glassfish.hk2.xml.internal.alt.AltAnnotation used on opensource projects

Example 1 with AltAnnotation

use of org.glassfish.hk2.xml.internal.alt.AltAnnotation in project glassfish-hk2 by eclipse-ee4j.

the class Generator method createAnnotationCopyOnly.

private static Annotation createAnnotationCopyOnly(ConstPool parent, AltAnnotation javaAnnotation) throws Throwable {
    Annotation annotation = new Annotation(javaAnnotation.annotationType(), parent);
    Map<String, Object> annotationValues = javaAnnotation.getAnnotationValues();
    for (Map.Entry<String, Object> entry : annotationValues.entrySet()) {
        String valueName = entry.getKey();
        Object value = entry.getValue();
        Class<?> javaAnnotationType = value.getClass();
        if (String.class.equals(javaAnnotationType)) {
            annotation.addMemberValue(valueName, new StringMemberValue((String) value, parent));
        } else if (Boolean.class.equals(javaAnnotationType)) {
            boolean bvalue = (Boolean) value;
            annotation.addMemberValue(valueName, new BooleanMemberValue(bvalue, parent));
        } else if (AltClass.class.isAssignableFrom(javaAnnotationType)) {
            AltClass altJavaAnnotationType = (AltClass) value;
            String sValue;
            if (javaAnnotation.annotationType().equals(XmlElement.class.getName()) && (javaAnnotation.getStringValue("getTypeByName") != null)) {
                sValue = javaAnnotation.getStringValue("getTypeByName");
            } else {
                sValue = altJavaAnnotationType.getName();
            }
            annotation.addMemberValue(valueName, new ClassMemberValue(sValue, parent));
        } else if (Integer.class.equals(javaAnnotationType)) {
            int ivalue = (Integer) value;
            annotation.addMemberValue(valueName, new IntegerMemberValue(parent, ivalue));
        } else if (Long.class.equals(javaAnnotationType)) {
            long lvalue = (Long) value;
            annotation.addMemberValue(valueName, new LongMemberValue(lvalue, parent));
        } else if (Double.class.equals(javaAnnotationType)) {
            double dvalue = (Double) value;
            annotation.addMemberValue(valueName, new DoubleMemberValue(dvalue, parent));
        } else if (Byte.class.equals(javaAnnotationType)) {
            byte bvalue = (Byte) value;
            annotation.addMemberValue(valueName, new ByteMemberValue(bvalue, parent));
        } else if (Character.class.equals(javaAnnotationType)) {
            char cvalue = (Character) value;
            annotation.addMemberValue(valueName, new CharMemberValue(cvalue, parent));
        } else if (Short.class.equals(javaAnnotationType)) {
            short svalue = (Short) value;
            annotation.addMemberValue(valueName, new ShortMemberValue(svalue, parent));
        } else if (Float.class.equals(javaAnnotationType)) {
            float fvalue = (Float) value;
            annotation.addMemberValue(valueName, new FloatMemberValue(fvalue, parent));
        } else if (AltEnum.class.isAssignableFrom(javaAnnotationType)) {
            AltEnum evalue = (AltEnum) value;
            EnumMemberValue jaEnum = new EnumMemberValue(parent);
            jaEnum.setType(evalue.getDeclaringClass());
            jaEnum.setValue(evalue.getName());
            annotation.addMemberValue(valueName, jaEnum);
        } else if (javaAnnotationType.isArray()) {
            Class<?> typeOfArray = javaAnnotationType.getComponentType();
            MemberValue[] arrayValue;
            if (int.class.equals(typeOfArray)) {
                int[] iVals = (int[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new IntegerMemberValue(parent, iVals[lcv]);
                }
            } else if (String.class.equals(typeOfArray)) {
                String[] iVals = (String[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new StringMemberValue(iVals[lcv], parent);
                }
            } else if (long.class.equals(typeOfArray)) {
                long[] iVals = (long[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new LongMemberValue(iVals[lcv], parent);
                }
            } else if (boolean.class.equals(typeOfArray)) {
                boolean[] iVals = (boolean[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new BooleanMemberValue(iVals[lcv], parent);
                }
            } else if (float.class.equals(typeOfArray)) {
                float[] iVals = (float[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new FloatMemberValue(iVals[lcv], parent);
                }
            } else if (double.class.equals(typeOfArray)) {
                double[] iVals = (double[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new DoubleMemberValue(iVals[lcv], parent);
                }
            } else if (byte.class.equals(typeOfArray)) {
                byte[] iVals = (byte[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new ByteMemberValue(iVals[lcv], parent);
                }
            } else if (char.class.equals(typeOfArray)) {
                char[] iVals = (char[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new CharMemberValue(iVals[lcv], parent);
                }
            } else if (short.class.equals(typeOfArray)) {
                short[] iVals = (short[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    arrayValue[lcv] = new ShortMemberValue(iVals[lcv], parent);
                }
            } else if (AltEnum.class.isAssignableFrom(typeOfArray)) {
                AltEnum[] iVals = (AltEnum[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    EnumMemberValue jaEnum = new EnumMemberValue(parent);
                    jaEnum.setType(iVals[lcv].getDeclaringClass());
                    jaEnum.setValue(iVals[lcv].getName());
                    arrayValue[lcv] = jaEnum;
                }
            } else if (AltClass.class.isAssignableFrom(typeOfArray)) {
                AltClass[] iVals = (AltClass[]) value;
                arrayValue = new MemberValue[iVals.length];
                for (int lcv = 0; lcv < iVals.length; lcv++) {
                    AltClass arrayElementClass = iVals[lcv];
                    arrayValue[lcv] = new ClassMemberValue(arrayElementClass.getName(), parent);
                }
            } else if (AltAnnotation.class.isAssignableFrom(typeOfArray)) {
                AltAnnotation[] aVals = (AltAnnotation[]) value;
                arrayValue = new MemberValue[aVals.length];
                for (int lcv = 0; lcv < aVals.length; lcv++) {
                    AltAnnotation arrayAnnotation = aVals[lcv];
                    arrayValue[lcv] = new AnnotationMemberValue(createAnnotationCopyOnly(parent, arrayAnnotation), parent);
                }
            } else {
                throw new AssertionError("Array type " + typeOfArray.getName() + " is not yet implemented for " + valueName);
            }
            ArrayMemberValue arrayMemberValue = new ArrayMemberValue(parent);
            arrayMemberValue.setValue(arrayValue);
            annotation.addMemberValue(valueName, arrayMemberValue);
        } else {
            throw new AssertionError("Annotation type " + javaAnnotationType.getName() + " is not yet implemented for " + valueName);
        }
    }
    return annotation;
}

Example 2 with AltAnnotation

use of org.glassfish.hk2.xml.internal.alt.AltAnnotation in project glassfish-hk2 by eclipse-ee4j.

the class Generator method generate.

/**
 * Converts the given interface into a JAXB implementation proxy
 *
 * @param convertMe
 * @param superClazz
 * @param defaultClassPool
 * @return
 * @throws Throwable
 */
public static CtClass generate(AltClass convertMe, CtClass superClazz, ClassPool defaultClassPool) throws Throwable {
    String modelOriginalInterface = convertMe.getName();
    String modelTranslatedClass = Utilities.getProxyNameFromInterfaceName(modelOriginalInterface);
    if (DEBUG_METHODS) {
        Logger.getLogger().debug("Converting " + convertMe.getName() + " to " + modelTranslatedClass);
    }
    CtClass targetCtClass = defaultClassPool.makeClass(modelTranslatedClass);
    ClassFile targetClassFile = targetCtClass.getClassFile();
    targetClassFile.setVersionToJava5();
    ConstPool targetConstPool = targetClassFile.getConstPool();
    ModelImpl compiledModel = new ModelImpl(modelOriginalInterface, modelTranslatedClass);
    AnnotationsAttribute ctAnnotations = null;
    String[] propOrder = null;
    for (AltAnnotation convertMeAnnotation : convertMe.getAnnotations()) {
        if (NO_COPY_ANNOTATIONS.contains(convertMeAnnotation.annotationType())) {
            // we do not want them to do
            continue;
        }
        if (ctAnnotations == null) {
            ctAnnotations = new AnnotationsAttribute(targetConstPool, AnnotationsAttribute.visibleTag);
        }
        if (XmlRootElement.class.getName().equals(convertMeAnnotation.annotationType())) {
            QName modelRootName = GeneratorUtilities.convertXmlRootElementName(convertMeAnnotation, convertMe);
            compiledModel.setRootName(modelRootName);
            String modelRootNameNamespace = QNameUtilities.getNamespace(modelRootName);
            String modelRootNameKey = modelRootName.getLocalPart();
            XmlRootElement replacement = new XmlRootElementImpl(modelRootNameNamespace, modelRootNameKey);
            createAnnotationCopy(targetConstPool, replacement, ctAnnotations);
        } else {
            createAnnotationCopy(targetConstPool, convertMeAnnotation, ctAnnotations);
        }
        if (XmlType.class.getName().equals(convertMeAnnotation.annotationType())) {
            propOrder = convertMeAnnotation.getStringArrayValue("propOrder");
        }
    }
    if (ctAnnotations != null) {
        targetClassFile.addAttribute(ctAnnotations);
    }
    CtClass originalCtClass = defaultClassPool.getOrNull(convertMe.getName());
    if (originalCtClass == null) {
        originalCtClass = defaultClassPool.makeInterface(convertMe.getName());
    }
    targetCtClass.setSuperclass(superClazz);
    targetCtClass.addInterface(originalCtClass);
    NameInformation xmlNameMap = GeneratorUtilities.getXmlNameMap(convertMe);
    Set<QName> alreadyAddedNaked = new LinkedHashSet<QName>();
    List<AltMethod> allMethods = convertMe.getMethods();
    if (DEBUG_METHODS) {
        Logger.getLogger().debug("Analyzing " + allMethods.size() + " methods of " + convertMe.getName());
    }
    allMethods = Utilities.prioritizeMethods(allMethods, propOrder, xmlNameMap);
    Set<String> setters = new LinkedHashSet<String>();
    Map<String, MethodInformationI> getters = new LinkedHashMap<String, MethodInformationI>();
    Map<String, GhostXmlElementData> elementsMethods = new LinkedHashMap<String, GhostXmlElementData>();
    for (AltMethod wrapper : allMethods) {
        MethodInformationI mi = Utilities.getMethodInformation(wrapper, xmlNameMap);
        if (mi.isKey()) {
            compiledModel.setKeyProperty(mi.getRepresentedProperty());
        }
        String miRepPropNamespace = QNameUtilities.getNamespace(mi.getRepresentedProperty());
        String miRepProp = (mi.getRepresentedProperty() == null) ? null : mi.getRepresentedProperty().getLocalPart();
        if (!MethodType.CUSTOM.equals(mi.getMethodType())) {
            createInterfaceForAltClassIfNeeded(mi.getGetterSetterType(), defaultClassPool);
        } else {
            // Custom methods can have all sorts of missing types, need to do all return and param types
            AltMethod original = mi.getOriginalMethod();
            AltClass originalReturn = original.getReturnType();
            if (!ClassAltClassImpl.VOID.equals(originalReturn)) {
                createInterfaceForAltClassIfNeeded(originalReturn, defaultClassPool);
            }
            for (AltClass parameter : original.getParameterTypes()) {
                createInterfaceForAltClassIfNeeded(parameter, defaultClassPool);
            }
        }
        if (DEBUG_METHODS) {
            Logger.getLogger().debug("Analyzing method " + mi + " of " + convertMe.getSimpleName());
        }
        String name = wrapper.getName();
        StringBuffer sb = new StringBuffer("public ");
        AltClass originalRetType = wrapper.getReturnType();
        boolean isVoid;
        if (originalRetType == null || void.class.getName().equals(originalRetType.getName())) {
            sb.append("void ");
            isVoid = true;
        } else {
            sb.append(getCompilableClass(originalRetType) + " ");
            isVoid = false;
        }
        sb.append(name + "(");
        AltClass childType = null;
        boolean getterOrSetter = false;
        boolean isReference = false;
        boolean isSetter = false;
        if (MethodType.SETTER.equals(mi.getMethodType())) {
            getterOrSetter = true;
            isSetter = true;
            setters.add(mi.getRepresentedProperty().getLocalPart());
            childType = mi.getBaseChildType();
            isReference = mi.isReference();
            sb.append(getCompilableClass(mi.getGetterSetterType()) + " arg0) { super._setProperty(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\", arg0); }");
        } else if (MethodType.GETTER.equals(mi.getMethodType())) {
            getterOrSetter = true;
            getters.put(mi.getRepresentedProperty().getLocalPart(), mi);
            childType = mi.getBaseChildType();
            isReference = mi.isReference();
            String cast = "";
            String superMethodName = "_getProperty";
            if (int.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "I";
            } else if (long.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "J";
            } else if (boolean.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "Z";
            } else if (byte.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "B";
            } else if (char.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "C";
            } else if (short.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "S";
            } else if (float.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "F";
            } else if (double.class.getName().equals(mi.getGetterSetterType().getName())) {
                superMethodName += "D";
            } else {
                cast = "(" + getCompilableClass(mi.getGetterSetterType()) + ") ";
            }
            sb.append(") { return " + cast + "super." + superMethodName + "(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\"); }");
        } else if (MethodType.LOOKUP.equals(mi.getMethodType())) {
            sb.append("java.lang.String arg0) { return (" + getCompilableClass(originalRetType) + ") super._lookupChild(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\", arg0); }");
        } else if (MethodType.ADD.equals(mi.getMethodType())) {
            String returnClause = "";
            if (!isVoid) {
                createInterfaceForAltClassIfNeeded(originalRetType, defaultClassPool);
                returnClause = "return (" + getCompilableClass(originalRetType) + ") ";
            }
            List<AltClass> paramTypes = wrapper.getParameterTypes();
            if (paramTypes.size() == 0) {
                sb.append(") { " + returnClause + "super._doAdd(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\", null, null, -1); }");
            } else if (paramTypes.size() == 1) {
                createInterfaceForAltClassIfNeeded(paramTypes.get(0), defaultClassPool);
                sb.append(paramTypes.get(0).getName() + " arg0) { " + returnClause + "super._doAdd(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\",");
                if (paramTypes.get(0).isInterface()) {
                    sb.append("arg0, null, -1); }");
                } else if (String.class.getName().equals(paramTypes.get(0).getName())) {
                    sb.append("null, arg0, -1); }");
                } else {
                    sb.append("null, null, arg0); }");
                }
            } else {
                sb.append(paramTypes.get(0).getName() + " arg0, int arg1) { " + returnClause + "super._doAdd(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\",");
                if (paramTypes.get(0).isInterface()) {
                    createInterfaceForAltClassIfNeeded(paramTypes.get(0), defaultClassPool);
                    sb.append("arg0, null, arg1); }");
                } else {
                    sb.append("null, arg0, arg1); }");
                }
            }
        } else if (MethodType.REMOVE.equals(mi.getMethodType())) {
            List<AltClass> paramTypes = wrapper.getParameterTypes();
            String cast = "";
            String function = "super._doRemoveZ(\"";
            String doReturn = "return";
            if (!boolean.class.getName().equals(originalRetType.getName())) {
                if (void.class.getName().equals(originalRetType.getName())) {
                    doReturn = "";
                } else {
                    cast = "(" + getCompilableClass(originalRetType) + ") ";
                }
                function = "super._doRemove(\"";
            }
            if (paramTypes.size() == 0) {
                sb.append(") { " + doReturn + " " + cast + function + miRepPropNamespace + "\",\"" + miRepProp + "\", null, -1, null); }");
            } else if (String.class.getName().equals(paramTypes.get(0).getName())) {
                sb.append("java.lang.String arg0) { " + doReturn + " " + cast + function + miRepPropNamespace + "\",\"" + miRepProp + "\", arg0, -1, null); }");
            } else if (int.class.getName().equals(paramTypes.get(0).getName())) {
                sb.append("int arg0) { " + doReturn + " " + cast + function + miRepPropNamespace + "\",\"" + miRepProp + "\", null, arg0, null); }");
            } else {
                sb.append(paramTypes.get(0).getName() + " arg0) { " + doReturn + " " + cast + function + miRepPropNamespace + "\",\"" + miRepProp + "\", null, -1, arg0); }");
            }
        } else if (MethodType.CUSTOM.equals(mi.getMethodType())) {
            List<AltClass> paramTypes = wrapper.getParameterTypes();
            StringBuffer classSets = new StringBuffer();
            StringBuffer valSets = new StringBuffer();
            int lcv = 0;
            for (AltClass paramType : paramTypes) {
                createInterfaceForAltClassIfNeeded(paramType, defaultClassPool);
                if (lcv == 0) {
                    sb.append(getCompilableClass(paramType) + " arg" + lcv);
                } else {
                    sb.append(", " + getCompilableClass(paramType) + " arg" + lcv);
                }
                classSets.append("mParams[" + lcv + "] = " + getCompilableClass(paramType) + ".class;\n");
                valSets.append("mVars[" + lcv + "] = ");
                if (int.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Integer(arg" + lcv + ");\n");
                } else if (long.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Long(arg" + lcv + ");\n");
                } else if (boolean.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Boolean(arg" + lcv + ");\n");
                } else if (byte.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Byte(arg" + lcv + ");\n");
                } else if (char.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Character(arg" + lcv + ");\n");
                } else if (short.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Short(arg" + lcv + ");\n");
                } else if (float.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Float(arg" + lcv + ");\n");
                } else if (double.class.getName().equals(paramType.getName())) {
                    valSets.append("new java.lang.Double(arg" + lcv + ");\n");
                } else {
                    valSets.append("arg" + lcv + ";\n");
                }
                lcv++;
            }
            sb.append(") { Class[] mParams = new Class[" + paramTypes.size() + "];\n");
            sb.append("Object[] mVars = new Object[" + paramTypes.size() + "];\n");
            sb.append(classSets.toString());
            sb.append(valSets.toString());
            String cast = "";
            String superMethodName = "_invokeCustomizedMethod";
            if (int.class.getName().equals(originalRetType.getName())) {
                superMethodName += "I";
            } else if (long.class.getName().equals(originalRetType.getName())) {
                superMethodName += "J";
            } else if (boolean.class.getName().equals(originalRetType.getName())) {
                superMethodName += "Z";
            } else if (byte.class.getName().equals(originalRetType.getName())) {
                superMethodName += "B";
            } else if (char.class.getName().equals(originalRetType.getName())) {
                superMethodName += "C";
            } else if (short.class.getName().equals(originalRetType.getName())) {
                superMethodName += "S";
            } else if (float.class.getName().equals(originalRetType.getName())) {
                superMethodName += "F";
            } else if (double.class.getName().equals(originalRetType.getName())) {
                superMethodName += "D";
            } else if (!isVoid) {
                cast = "(" + getCompilableClass(originalRetType) + ") ";
            }
            if (!isVoid) {
                sb.append("return " + cast);
            }
            sb.append("super." + superMethodName + "(\"" + name + "\", mParams, mVars);}");
        } else {
            throw new AssertionError("Unknown method type: " + mi.getMethodType());
        }
        if (DEBUG_METHODS) {
            // Hidden behind static because of potential expensive toString costs
            Logger.getLogger().debug("Adding method for " + convertMe.getSimpleName() + " with implementation " + sb);
        }
        CtMethod addMeCtMethod;
        try {
            addMeCtMethod = CtNewMethod.make(sb.toString(), targetCtClass);
        } catch (CannotCompileException cce) {
            MultiException me = new MultiException(cce);
            me.addError(new AssertionError("Cannot compile method with source " + sb.toString()));
            throw me;
        }
        if (wrapper.isVarArgs()) {
            addMeCtMethod.setModifiers(addMeCtMethod.getModifiers() | Modifier.VARARGS);
        }
        if (mi.getListParameterizedType() != null) {
            addListGenericSignature(addMeCtMethod, mi.getListParameterizedType(), isSetter);
        }
        MethodInfo methodInfo = addMeCtMethod.getMethodInfo();
        ConstPool methodConstPool = methodInfo.getConstPool();
        ctAnnotations = null;
        for (AltAnnotation convertMeAnnotation : wrapper.getAnnotations()) {
            if (NO_COPY_ANNOTATIONS_METHOD.contains(convertMeAnnotation.annotationType())) {
                continue;
            }
            if (ctAnnotations == null) {
                ctAnnotations = new AnnotationsAttribute(methodConstPool, AnnotationsAttribute.visibleTag);
            }
            if ((childType != null) && XmlElement.class.getName().equals(convertMeAnnotation.annotationType())) {
                String translatedClassName = Utilities.getProxyNameFromInterfaceName(childType.getName());
                java.lang.annotation.Annotation anno = new XmlElementImpl(convertMeAnnotation.getStringValue("name"), convertMeAnnotation.getBooleanValue("nillable"), convertMeAnnotation.getBooleanValue("required"), convertMeAnnotation.getStringValue("namespace"), convertMeAnnotation.getStringValue("defaultValue"), translatedClassName);
                createAnnotationCopy(methodConstPool, anno, ctAnnotations);
            } else if (getterOrSetter && XmlElements.class.getName().equals(convertMeAnnotation.annotationType())) {
                QName representedProperty = mi.getRepresentedProperty();
                AltAnnotation[] elements = convertMeAnnotation.getAnnotationArrayValue("value");
                if (elements == null)
                    elements = new AltAnnotation[0];
                elementsMethods.put(representedProperty.getLocalPart(), new GhostXmlElementData(elements, mi.getGetterSetterType()));
            // Note the XmlElements is NOT copied to the proxy, the ghost methods will get the XmlElements
            } else {
                createAnnotationCopy(methodConstPool, convertMeAnnotation, ctAnnotations);
            }
        }
        if (getterOrSetter) {
            String originalMethodName = mi.getOriginalMethodName();
            List<XmlElementData> aliases = xmlNameMap.getAliases(mi.getRepresentedProperty().getLocalPart());
            boolean required = mi.isRequired();
            if ((childType != null) || (aliases != null)) {
                if (!isReference) {
                    AliasType aType = (aliases == null) ? AliasType.NORMAL : AliasType.HAS_ALIASES;
                    AltClass useChildType = (childType == null) ? mi.getListParameterizedType() : childType;
                    AdapterInformation adapterInformation = mi.getAdapterInformation();
                    String adapterClass = (adapterInformation == null) ? null : adapterInformation.getAdapter().getName();
                    if (useChildType.isInterface()) {
                        compiledModel.addChild(useChildType.getName(), QNameUtilities.getNamespace(mi.getRepresentedProperty()), mi.getRepresentedProperty().getLocalPart(), mi.getRepresentedProperty().getLocalPart(), getChildType(mi.isList(), mi.isArray()), mi.getDefaultValue(), aType, mi.getWrapperTag(), adapterClass, required, originalMethodName);
                    } else {
                        compiledModel.addNonChild(QNameUtilities.getNamespace(mi.getRepresentedProperty()), mi.getRepresentedProperty().getLocalPart(), mi.getDefaultValue(), mi.getGetterSetterType().getName(), mi.getListParameterizedType().getName(), false, Format.ELEMENT, aType, null, required, originalMethodName);
                    }
                    if (aliases != null) {
                        for (XmlElementData alias : aliases) {
                            String aliasType = alias.getType();
                            if (aliasType == null)
                                aliasType = useChildType.getName();
                            if (alias.isTypeInterface()) {
                                compiledModel.addChild(aliasType, alias.getNamespace(), alias.getName(), alias.getAlias(), getChildType(mi.isList(), mi.isArray()), alias.getDefaultValue(), AliasType.IS_ALIAS, mi.getWrapperTag(), adapterClass, required, originalMethodName);
                            } else {
                                compiledModel.addNonChild(alias.getNamespace(), alias.getName(), alias.getDefaultValue(), mi.getGetterSetterType().getName(), aliasType, false, Format.ELEMENT, AliasType.IS_ALIAS, alias.getAlias(), required, originalMethodName);
                            }
                        }
                    }
                } else {
                    // Is a reference
                    String listPType = (mi.getListParameterizedType() == null) ? null : mi.getListParameterizedType().getName();
                    compiledModel.addNonChild(mi.getRepresentedProperty(), mi.getDefaultValue(), mi.getGetterSetterType().getName(), listPType, true, mi.getFormat(), AliasType.NORMAL, null, required, originalMethodName);
                }
            } else {
                String listPType = (mi.getListParameterizedType() == null) ? null : mi.getListParameterizedType().getName();
                compiledModel.addNonChild(mi.getRepresentedProperty(), mi.getDefaultValue(), mi.getGetterSetterType().getName(), listPType, false, mi.getFormat(), AliasType.NORMAL, null, required, originalMethodName);
            }
        }
        if (getterOrSetter && childType != null && xmlNameMap.hasNoXmlElement(mi.getRepresentedProperty().getLocalPart()) && !alreadyAddedNaked.contains(mi.getRepresentedProperty())) {
            alreadyAddedNaked.add(mi.getRepresentedProperty());
            if (ctAnnotations == null) {
                ctAnnotations = new AnnotationsAttribute(methodConstPool, AnnotationsAttribute.visibleTag);
            }
            java.lang.annotation.Annotation convertMeAnnotation;
            String translatedClassName = Utilities.getProxyNameFromInterfaceName(childType.getName());
            convertMeAnnotation = new XmlElementImpl(JAXB_DEFAULT_STRING, false, false, JAXB_DEFAULT_STRING, JAXB_DEFAULT_DEFAULT, translatedClassName);
            if (DEBUG_METHODS) {
                Logger.getLogger().debug("Adding ghost XmlElement for " + convertMe.getSimpleName() + " with data " + convertMeAnnotation);
            }
            createAnnotationCopy(methodConstPool, convertMeAnnotation, ctAnnotations);
        }
        if (ctAnnotations != null) {
            methodInfo.addAttribute(ctAnnotations);
        }
        targetCtClass.addMethod(addMeCtMethod);
    }
    // Now generate the invisible setters for JAXB
    for (Map.Entry<String, MethodInformationI> getterEntry : getters.entrySet()) {
        String getterProperty = getterEntry.getKey();
        MethodInformationI mi = getterEntry.getValue();
        String miRepPropNamespace = QNameUtilities.getNamespace(mi.getRepresentedProperty());
        String miRepProp = mi.getRepresentedProperty().getLocalPart();
        if (setters.contains(getterProperty))
            continue;
        String getterName = mi.getOriginalMethod().getName();
        String setterName = Utilities.convertToSetter(getterName);
        StringBuffer sb = new StringBuffer("private void " + setterName + "(");
        sb.append(getCompilableClass(mi.getGetterSetterType()) + " arg0) { super._setProperty(\"" + miRepPropNamespace + "\",\"" + miRepProp + "\", arg0); }");
        CtMethod addMeCtMethod = CtNewMethod.make(sb.toString(), targetCtClass);
        targetCtClass.addMethod(addMeCtMethod);
        if (mi.getListParameterizedType() != null) {
            addListGenericSignature(addMeCtMethod, mi.getListParameterizedType(), true);
        }
        if (DEBUG_METHODS) {
            Logger.getLogger().debug("Adding ghost setter method for " + convertMe.getSimpleName() + " with implementation " + sb);
        }
    }
    int elementCount = 0;
    for (Map.Entry<String, GhostXmlElementData> entry : elementsMethods.entrySet()) {
        String basePropName = entry.getKey();
        GhostXmlElementData gxed = entry.getValue();
        AltAnnotation[] xmlElements = gxed.xmlElements;
        String baseSetSetterName = "set_" + basePropName;
        String baseGetterName = "get_" + basePropName;
        for (AltAnnotation xmlElement : xmlElements) {
            String elementName = xmlElement.getStringValue("name");
            String elementNamespace = xmlElement.getStringValue("namespace");
            String ghostMethodName = baseSetSetterName + "_" + elementCount;
            String ghostMethodGetName = baseGetterName + "_" + elementCount;
            elementCount++;
            AltClass ac = (AltClass) xmlElement.getAnnotationValues().get("type");
            {
                // Create the setter
                StringBuffer ghostBufferSetter = new StringBuffer("private void " + ghostMethodName + "(");
                ghostBufferSetter.append(getCompilableClass(gxed.getterSetterType) + " arg0) { super._setProperty(\"" + elementNamespace + "\",\"" + elementName + "\", arg0); }");
                if (DEBUG_METHODS) {
                    Logger.getLogger().debug("Adding ghost XmlElements setter method for " + convertMe.getSimpleName() + " with implementation " + ghostBufferSetter);
                }
                CtMethod elementsCtMethod = CtNewMethod.make(ghostBufferSetter.toString(), targetCtClass);
                addListGenericSignature(elementsCtMethod, ac, true);
                targetCtClass.addMethod(elementsCtMethod);
            }
            {
                // Create the getter
                StringBuffer ghostBufferGetter = new StringBuffer("private " + getCompilableClass(gxed.getterSetterType) + " " + ghostMethodGetName + "() { return (" + getCompilableClass(gxed.getterSetterType) + ") super._getProperty(\"" + elementNamespace + "\",\"" + elementName + "\"); }");
                CtMethod elementsCtMethodGetter = CtNewMethod.make(ghostBufferGetter.toString(), targetCtClass);
                addListGenericSignature(elementsCtMethodGetter, ac, false);
                MethodInfo elementsMethodInfo = elementsCtMethodGetter.getMethodInfo();
                ConstPool elementsMethodConstPool = elementsMethodInfo.getConstPool();
                AnnotationsAttribute aa = new AnnotationsAttribute(elementsMethodConstPool, AnnotationsAttribute.visibleTag);
                String translatedClassName;
                if (ac.isInterface()) {
                    translatedClassName = Utilities.getProxyNameFromInterfaceName(ac.getName());
                } else {
                    translatedClassName = ac.getName();
                }
                XmlElement xElement = new XmlElementImpl(elementName, xmlElement.getBooleanValue("nillable"), xmlElement.getBooleanValue("required"), xmlElement.getStringValue("namespace"), xmlElement.getStringValue("defaultValue"), translatedClassName);
                createAnnotationCopy(elementsMethodConstPool, xElement, aa);
                elementsMethodInfo.addAttribute(aa);
                if (DEBUG_METHODS) {
                    Logger.getLogger().debug("Adding ghost XmlElements getter method for " + convertMe.getSimpleName() + " with implementation " + ghostBufferGetter);
                    Logger.getLogger().debug("with XmlElement " + xElement);
                }
                targetCtClass.addMethod(elementsCtMethodGetter);
            }
        }
    }
    generateStaticModelFieldAndAbstractMethodImpl(targetCtClass, compiledModel, defaultClassPool);
    return targetCtClass;
}

Example 3 with AltAnnotation

use of org.glassfish.hk2.xml.internal.alt.AltAnnotation in project glassfish-hk2 by eclipse-ee4j.

the class ClassAltClassImpl method getAnnotations.

/* (non-Javadoc)
     * @see org.glassfish.hk2.xml.internal.alt.AltClass#getAnnotations()
     */
@Override
public synchronized List<AltAnnotation> getAnnotations() {
    if (annotations != null)
        return annotations;
    Annotation[] annotationz = clazz.getAnnotations();
    ArrayList<AltAnnotation> retVal = new ArrayList<AltAnnotation>(annotationz.length);
    for (Annotation annotation : annotationz) {
        retVal.add(new AnnotationAltAnnotationImpl(annotation, helper));
    }
    annotations = Collections.unmodifiableList(retVal);
    return annotations;
}

Example 4 with AltAnnotation

use of org.glassfish.hk2.xml.internal.alt.AltAnnotation in project glassfish-hk2 by eclipse-ee4j.

the class AnnotationMirrorAltAnnotationImpl method getAnnotationValues.

/* (non-Javadoc)
     * @see org.glassfish.hk2.xml.internal.alt.AltAnnotation#getAnnotationValues()
     */
@Override
public synchronized Map<String, Object> getAnnotationValues() {
    if (values != null)
        return values;
    Map<? extends ExecutableElement, ? extends AnnotationValue> rawValues = processingEnv.getElementUtils().getElementValuesWithDefaults(annotation);
    Map<String, Object> retVal = new TreeMap<String, Object>();
    for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : rawValues.entrySet()) {
        ExecutableElement annoMethod = entry.getKey();
        AnnotationValue annoValue = entry.getValue();
        String key = Utilities.convertNameToString(annoMethod.getSimpleName());
        Object value = annoValue.getValue();
        if (value instanceof TypeMirror) {
            // The annotation method is a java.lang.Class
            value = Utilities.convertTypeMirror((TypeMirror) value, processingEnv);
        } else if (value instanceof VariableElement) {
            // The annotation method is an Enum
            VariableElement variable = (VariableElement) value;
            TypeElement enclosing = (TypeElement) variable.getEnclosingElement();
            String annoClassName = Utilities.convertNameToString(enclosing.getQualifiedName());
            String annoVal = Utilities.convertNameToString(variable.getSimpleName());
            value = new StringAltEnumImpl(annoClassName, annoVal);
        } else if (value instanceof AnnotationMirror) {
            throw new AssertionError("The annotation " + annotation + " key " + key + " has unimplemented type AnnotationMirror");
        } else if (value instanceof List) {
            // The annotation method returns an array of something
            ArrayType returnType = (ArrayType) annoMethod.getReturnType();
            TypeMirror arrayTypeMirror = returnType.getComponentType();
            TypeKind arrayTypeKind = arrayTypeMirror.getKind();
            @SuppressWarnings("unchecked") List<? extends AnnotationValue> array = ((List<? extends AnnotationValue>) value);
            if (TypeKind.INT.equals(arrayTypeMirror.getKind())) {
                int[] iValue = new int[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Integer) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.DECLARED.equals(arrayTypeMirror.getKind())) {
                AltClass[] cValue = new AltClass[array.size()];
                AltEnum[] eValue = new AltEnum[array.size()];
                String[] sValue = new String[array.size()];
                AltAnnotation[] aValue = new AltAnnotation[array.size()];
                boolean isClass = true;
                boolean isEnum = true;
                boolean isAnnos = false;
                int lcv = 0;
                for (AnnotationValue item : array) {
                    Object itemValue = item.getValue();
                    if (itemValue instanceof TypeMirror) {
                        isClass = true;
                        isEnum = false;
                        isAnnos = false;
                        cValue[lcv++] = Utilities.convertTypeMirror((TypeMirror) itemValue, processingEnv);
                    } else if (itemValue instanceof VariableElement) {
                        isClass = false;
                        isEnum = true;
                        isAnnos = false;
                        VariableElement variable = (VariableElement) itemValue;
                        TypeElement enclosing = (TypeElement) variable.getEnclosingElement();
                        String annoClassName = Utilities.convertNameToString(enclosing.getQualifiedName());
                        String annoVal = Utilities.convertNameToString(variable.getSimpleName());
                        eValue[lcv++] = new StringAltEnumImpl(annoClassName, annoVal);
                    } else if (itemValue instanceof String) {
                        isClass = false;
                        isEnum = false;
                        isAnnos = false;
                        sValue[lcv++] = (String) itemValue;
                    } else if (itemValue instanceof List) {
                        throw new AssertionError("Unimplemented declared List type in " + this);
                    } else if (itemValue instanceof AnnotationMirror) {
                        isClass = false;
                        isEnum = false;
                        isAnnos = true;
                        aValue[lcv++] = new AnnotationMirrorAltAnnotationImpl((AnnotationMirror) itemValue, processingEnv);
                    } else {
                        throw new AssertionError("Unknown declared type: " + itemValue.getClass().getName());
                    }
                }
                if (isClass) {
                    value = cValue;
                } else if (isEnum) {
                    value = eValue;
                } else if (isAnnos) {
                    value = aValue;
                } else {
                    value = sValue;
                }
            } else if (TypeKind.LONG.equals(arrayTypeMirror.getKind())) {
                long[] iValue = new long[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Long) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.SHORT.equals(arrayTypeMirror.getKind())) {
                short[] iValue = new short[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Short) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.CHAR.equals(arrayTypeMirror.getKind())) {
                char[] iValue = new char[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Character) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.FLOAT.equals(arrayTypeMirror.getKind())) {
                float[] iValue = new float[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Float) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.DOUBLE.equals(arrayTypeMirror.getKind())) {
                double[] iValue = new double[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Double) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.BOOLEAN.equals(arrayTypeMirror.getKind())) {
                boolean[] iValue = new boolean[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Boolean) item.getValue();
                }
                value = iValue;
            } else if (TypeKind.BYTE.equals(arrayTypeMirror.getKind())) {
                byte[] iValue = new byte[array.size()];
                int lcv = 0;
                for (AnnotationValue item : array) {
                    iValue[lcv++] = (Byte) item.getValue();
                }
                value = iValue;
            } else {
                throw new AssertionError("Array type " + arrayTypeKind + " is not implemented");
            }
        }
        retVal.put(key, value);
    }
    values = Collections.unmodifiableMap(retVal);
    return values;
}

Example 5 with AltAnnotation

use of org.glassfish.hk2.xml.internal.alt.AltAnnotation in project glassfish-hk2 by eclipse-ee4j.

the class TypeElementAltClassImpl method getAnnotations.

/* (non-Javadoc)
     * @see org.glassfish.hk2.xml.internal.alt.AltClass#getAnnotations()
     */
@Override
public synchronized List<AltAnnotation> getAnnotations() {
    if (annotations != null)
        return annotations;
    List<? extends AnnotationMirror> annoMirrors = processingEnv.getElementUtils().getAllAnnotationMirrors(clazz);
    ArrayList<AltAnnotation> retVal = new ArrayList<AltAnnotation>(annoMirrors.size());
    for (AnnotationMirror annoMirror : annoMirrors) {
        AnnotationMirrorAltAnnotationImpl anno = new AnnotationMirrorAltAnnotationImpl(annoMirror, processingEnv);
        retVal.add(anno);
    }
    annotations = Collections.unmodifiableList(new ArrayList<AltAnnotation>(retVal));
    return annotations;
}