java类javax.xml.bind.annotation.XmlEnumValue的实例源码

private XmlToEnumMapper(T[] enumValues) {
  ImmutableMap.Builder<String, T> mapBuilder = new ImmutableMap.Builder<>();
  for (T value : enumValues) {
    try {
      XmlEnumValue xmlAnnotation = value
          .getDeclaringClass()
          .getField(value.name())
          .getAnnotation(XmlEnumValue.class);
      checkArgumentNotNull(xmlAnnotation, "Cannot map enum value to xml name: " + value);
      String xmlName = xmlAnnotation.value();
      mapBuilder = mapBuilder.put(xmlName, value);
    } catch (NoSuchFieldException e) {
      throw new RuntimeException(e);
    }
  }
  map = mapBuilder.build();
}

public static <E extends Enum<E>> String toString(final E value) {

        final Class<E> enumType = value.getDeclaringClass();
        try {
            final XmlEnumValue xmlEnumValue = enumType.getField(value.name())
                .getAnnotation(XmlEnumValue.class);
            if (xmlEnumValue != null && xmlEnumValue.value() != null) {
                return xmlEnumValue.value();
            } else {
                return value.name();
            }
        } catch (NoSuchFieldException
                 | SecurityException e1) {
            throw new RuntimeException(e1);
        }

    }

public static <E extends Enum<E>> E valueOf(final Class<E> enumType,
    final String name) {

    if (!isNotNullOrEmpty(name)) {
        return null;
    }
    try {
        for (final E e : enumType.getEnumConstants()) {
            String ename = e.name();
            final XmlEnumValue xmlEnumValue = enumType.getField(ename)
                .getAnnotation(XmlEnumValue.class);
            if (xmlEnumValue != null && xmlEnumValue.value() != null) {
                ename = xmlEnumValue.value();
            }
            if (name.equals(ename)) {
                return e;
            }
        }
    } catch (NoSuchFieldException
             | SecurityException e1) {
        throw new RuntimeException(e1);
    }
    throw new IllegalArgumentException("unable to find the value " + name + " in enum " + enumType);

}

/**
 * Build {@link EnumConstant}s and discover/report any error in it.
 */
protected void calcConstants() {
    EnumConstantImpl<T,C,F,M> last = null;
    F[] constants = nav().getEnumConstants(clazz);
    for( int i=constants.length-1; i>=0; i-- ) {
        F constant = constants[i];
        String name = nav().getFieldName(constant);
        XmlEnumValue xev = builder.reader.getFieldAnnotation(XmlEnumValue.class, constant, this);

        String literal;
        if(xev==null)   literal = name;
        else            literal = xev.value();

        last = createEnumConstant(name,literal,constant,last);
    }
    this.firstConstant = last;
}

static
public String getEnumValue(Enum<?> value){
    Class<?> clazz = value.getClass();

    Field field;

    try {
        field = clazz.getField(value.name());
    } catch(NoSuchFieldException nsfe){
        throw new RuntimeException(nsfe);
    }

    XmlEnumValue enumValue = field.getAnnotation(XmlEnumValue.class);
    if(enumValue != null){
        return enumValue.value();
    }

    throw new IllegalArgumentException();
}

private <T> String findEnumFieldNameUncached(Class classType, T primValue){
    for (Field field: classType.getDeclaredFields()) {
        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null && xmlEnumValue.value().equals(primValue)) {
            return field.getName();
        }
    }
    return null;
}

public static String findEnumFieldValueUncached(Class classType, String toStringValue){
    for (Field field: classType.getDeclaredFields()) {
        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null && field.getName().equals(toStringValue)) {
            return xmlEnumValue.value();
        }
    }
    return null;
}

/** Read the {@link XmlEnumValue} string off of an enum. */
public static String enumToXml(Enum<?> input) {
  try {
    return input.getClass().getField(input.name()).getAnnotation(XmlEnumValue.class).value();
  } catch (NoSuchFieldException e) {
    throw new RuntimeException(e);
  }
}

@XmlEnumValue("2008")
BIS_APRIL_2014("2008"),
@XmlEnumValue("2014")
AB_MAI_2014("2014"),
@XmlEnumValue("ohne")
OHNE("ohne"),
@XmlEnumValue("nicht_noetig")
NICHT_NOETIG("nicht_noetig"),
@XmlEnumValue("bei_besichtigung")
BEI_BESICHTIGUNG("bei_besichtigung");

@XmlEnumValue("for-sale")
FOR_SALE("for-sale"),
@XmlEnumValue("sale-agreed")
SALE_AGREED("sale-agreed"),
@XmlEnumValue("sold")
SOLD("sold");

/**
 * Extract from an Enum the {@link javax.xml.bind.annotation.XmlEnumValue} that are associated with its fields.
 *
 * @param clazz The class that is to be introspected
 * @return A map that maps {@link javax.xml.bind.annotation.XmlEnumValue#value()} to the enum name itself.
 */
protected Map<String, String> extractXmlValueFromEnumAnnotations(Class clazz) {
    Map<String, String> annotationToName = Maps.newHashMap();
    Field[] fields = clazz.getFields();
    for (Field field : fields) {
        if (field.isAnnotationPresent(XmlEnumValue.class)) {
            XmlEnumValue annotation = field.getAnnotation(XmlEnumValue.class);
            annotationToName.put(annotation.value(), field.getName());
        }
    }
    return annotationToName;
}

public void setSubjectTypesSupported(final SubjectIdentifierType... subjectTypesSupported) {

        this.subjectTypesSupported = new HashSet<>(subjectTypesSupported.length);
        for (final SubjectIdentifierType subjectType : subjectTypesSupported) {
            try {
                this.subjectTypesSupported.add(subjectType.getClass().getField(((Enum<SubjectIdentifierType>) subjectType).name()).getAnnotation(XmlEnumValue.class).value());
            } catch (NoSuchFieldException
                | SecurityException e) {
                throw new IllegalArgumentException(e);
            }
        }
    }

private <T> String findEnumFieldNameUncached(Class classType, T primValue){
    for (Field field: classType.getDeclaredFields()) {
        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null && xmlEnumValue.value().equals(primValue)) {
            return field.getName();
        }
    }
    return null;
}

public static String findEnumFieldValueUncached(Class classType, String toStringValue){
    for (Field field: classType.getDeclaredFields()) {
        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null && field.getName().equals(toStringValue)) {
            return xmlEnumValue.value();
        }
    }
    return null;
}

private <T> String findEnumFieldNameUncached(Class classType, T primValue){
    for (Field field: classType.getDeclaredFields()) {
        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null && xmlEnumValue.value().equals(primValue)) {
            return field.getName();
        }
    }
    return null;
}

public static String findEnumFieldValueUncached(Class classType, String toStringValue){
    for (Field field: classType.getDeclaredFields()) {
        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null && field.getName().equals(toStringValue)) {
            return xmlEnumValue.value();
        }
    }
    return null;
}

private <T> Collection<? extends DisplayableValue<T>> parseEnumAllowedValues(QName typeName,
        ComplexTypeDefinition ctd, XSType xsType) {
    if (xsType.isSimpleType()) {
        if (xsType.asSimpleType().isRestriction()) {
            XSRestrictionSimpleType restriction = xsType.asSimpleType().asRestriction();
            List<XSFacet> enumerations = restriction.getDeclaredFacets(XSFacet.FACET_ENUMERATION);
            List<DisplayableValueImpl<T>> enumValues = new ArrayList<DisplayableValueImpl<T>>(
                    enumerations.size());
            for (XSFacet facet : enumerations) {
                String value = facet.getValue().value;
                Element descriptionE = SchemaProcessorUtil.getAnnotationElement(facet.getAnnotation(),
                        SCHEMA_DOCUMENTATION);
                Element appInfo = SchemaProcessorUtil.getAnnotationElement(facet.getAnnotation(),
                        SCHEMA_APP_INFO);
                Element valueE = null;
                if (appInfo != null) {
                    NodeList list = appInfo.getElementsByTagNameNS(
                            PrismConstants.A_LABEL.getNamespaceURI(),
                            PrismConstants.A_LABEL.getLocalPart());
                    if (list.getLength() != 0) {
                        valueE = (Element) list.item(0);
                    }
                }
                String label = null;
                if (valueE != null) {
                    label = valueE.getTextContent();
                } else {
                    label = value;
                }
                DisplayableValueImpl<T> edv = null;
                Class compileTimeClass = prismContext.getSchemaRegistry().getCompileTimeClass(typeName);
                if (ctd != null && !ctd.isRuntimeSchema() && compileTimeClass != null) {

                    String fieldName = null;
                    for (Field field : compileTimeClass.getDeclaredFields()) {
                        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
                        if (xmlEnumValue != null && xmlEnumValue.value() != null
                                && xmlEnumValue.value().equals(value)) {
                            fieldName = field.getName();
                        }

                    }
                    if (fieldName != null) {
                        T enumValue = (T) Enum.valueOf((Class<Enum>) compileTimeClass, fieldName);
                        edv = new DisplayableValueImpl(enumValue, label,
                                descriptionE != null ? descriptionE.getTextContent() : null);
                    } else {
                        edv = new DisplayableValueImpl(value, label,
                                descriptionE != null ? descriptionE.getTextContent() : null);
                    }


                } else {
                edv = new DisplayableValueImpl(value, label,
                        descriptionE != null ? descriptionE.getTextContent() : null);
                }
                enumValues.add(edv);

            }
            if (enumValues != null && !enumValues.isEmpty()) {
                return enumValues;
            }

        }
    }
    return null;
}

@XmlEnumValue("wohn")
WOHN("wohn"),
@XmlEnumValue("nichtwohn")
NICHTWOHN("nichtwohn");

@XmlEnumValue("weekly")
WEEKLY("weekly"),
@XmlEnumValue("monthly")
MONTHLY("monthly");

/**
 * Query the Class type to find a WITH setter method for the indicated field.
 * <p>
 * @param type  the class type
 * @param field the field
 * @return
 * @throws ClassNotFoundException
 * @throws IllegalAccessException
 * @throws IllegalArgumentException
 * @throws InvocationTargetException
 */
private static Object getEnumEntry(Class<?> type, Field field) throws ClassNotFoundException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
  /**
   * Inspect the WITH setter to determine if the field expects an enumerated
   * input.
   */
  Method with = SSRFUtility.findWithEnumMethod(type, field);
  if (with != null) {
    for (Class<?> parameterType : with.getParameterTypes()) {
      if (parameterType.isEnum()) {
        String fieldClassName = parameterType.toString().replace("class ", "").trim();
        Class<?> fieldClass = Class.forName(fieldClassName); // throws ClassNotFoundException
        /**
         * Get a random instance of the enumerated class type.
         */
        Enum fieldInstance = (Enum) fieldClass.getEnumConstants()[new Random().nextInt(fieldClass.getEnumConstants().length)];
        /**
         * If the instance has an XmlEnumValue annotation then return the XML
         * value.
         */
        XmlEnumValue xmlEnumValue = fieldInstance.getClass().getAnnotation(XmlEnumValue.class);
        if (xmlEnumValue != null) {
          return xmlEnumValue.value();
        }
        /**
         * Otherwise try to call the value getter.
         */
        for (Method method : fieldClass.getDeclaredMethods()) {
          if (method.getName().equals("value")) {
            return method.invoke(fieldInstance);
          }
        }
        /**
         * Finally just return the numerated instance name.
         */
        return fieldInstance.name();
      }
    }
  }
  /**
   * No enumerated instance found. Return null.
   */
  return null;
}

public static JsonObject convertToJson(final Object obj) {

        final JsonObjectBuilder b = Json.createObjectBuilder();

        try {
            final Class<?> objClass = obj.getClass();
            for (final Field field : objClass.getDeclaredFields()) {
                String name = field.getName();
                if (field.getAnnotation(XmlTransient.class) != null) {
                    continue;
                }

                final XmlElement xmlElement = field.getAnnotation(XmlElement.class);
                if (xmlElement != null && xmlElement.name() != null) {
                    name = xmlElement.name();
                }
                field.setAccessible(true);
                final Object value = field.get(obj);
                if (value == null) {
                    continue;
                }
                if (field.getType()
                    .isEnum()) {
                    final String enumValue = ((Enum<?>) value).name();
                    final XmlEnumValue xmlEnumValue = ((Enum<?>) value).getDeclaringClass()
                        .getField(enumValue)
                        .getAnnotation(XmlEnumValue.class);
                    if (xmlEnumValue != null && xmlEnumValue.value() != null) {
                        b.add(name, xmlEnumValue.value());
                    } else {
                        b.add(name, enumValue);
                    }

                } else if (field.getType() == String.class) {
                    b.add(name, (String) value);
                } else if (field.getType() == Integer.class) {
                    b.add(name, (Integer) value);
                } else if (field.getType() == BigInteger.class) {
                    b.add(name, (BigInteger) value);
                }
            }
            return b.build();
        } catch (IllegalAccessException
                 | SecurityException
                 | NoSuchFieldException e1) {
            throw new RuntimeException(e1);
        }
    }

private <T> Collection<? extends DisplayableValue<T>> parseEnumAllowedValues(QName typeName,
        ComplexTypeDefinition ctd, XSType xsType) {
    if (xsType.isSimpleType()) {
        if (xsType.asSimpleType().isRestriction()) {
            XSRestrictionSimpleType restriction = xsType.asSimpleType().asRestriction();
            List<XSFacet> enumerations = restriction.getDeclaredFacets(XSFacet.FACET_ENUMERATION);
            List<DisplayableValueImpl<T>> enumValues = new ArrayList<DisplayableValueImpl<T>>(
                    enumerations.size());
            for (XSFacet facet : enumerations) {
                String value = facet.getValue().value;
                Element descriptionE = SchemaProcessorUtil.getAnnotationElement(facet.getAnnotation(),
                        SCHEMA_DOCUMENTATION);
                Element appInfo = SchemaProcessorUtil.getAnnotationElement(facet.getAnnotation(),
                        SCHEMA_APP_INFO);
                Element valueE = null;
                if (appInfo != null) {
                    NodeList list = appInfo.getElementsByTagNameNS(
                            PrismConstants.A_LABEL.getNamespaceURI(),
                            PrismConstants.A_LABEL.getLocalPart());
                    if (list.getLength() != 0) {
                        valueE = (Element) list.item(0);
                    }
                }
                String label = null;
                if (valueE != null) {
                    label = valueE.getTextContent();
                } else {
                    label = value;
                }
                DisplayableValueImpl<T> edv = null;
                Class compileTimeClass = prismContext.getSchemaRegistry().getCompileTimeClass(typeName);
                if (ctd != null && !ctd.isRuntimeSchema() && compileTimeClass != null) {

                    String fieldName = null;
                    for (Field field : compileTimeClass.getDeclaredFields()) {
                        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
                        if (xmlEnumValue != null && xmlEnumValue.value() != null
                                && xmlEnumValue.value().equals(value)) {
                            fieldName = field.getName();
                        }

                    }
                    if (fieldName != null) {
                        T enumValue = (T) Enum.valueOf((Class<Enum>) compileTimeClass, fieldName);
                        edv = new DisplayableValueImpl(enumValue, label,
                                descriptionE != null ? descriptionE.getTextContent() : null);
                    } else {
                        edv = new DisplayableValueImpl(value, label,
                                descriptionE != null ? descriptionE.getTextContent() : null);
                    }


                } else {
                edv = new DisplayableValueImpl(value, label,
                        descriptionE != null ? descriptionE.getTextContent() : null);
                }
                enumValues.add(edv);

            }
            if (enumValues != null && !enumValues.isEmpty()) {
                return enumValues;
            }

        }
    }
    return null;
}

private <T> Collection<? extends DisplayableValue<T>> parseEnumAllowedValues(QName typeName,
        ComplexTypeDefinition ctd, XSType xsType) {
    if (xsType.isSimpleType()) {
        if (xsType.asSimpleType().isRestriction()) {
            XSRestrictionSimpleType restriction = xsType.asSimpleType().asRestriction();
            List<XSFacet> enumerations = restriction.getDeclaredFacets(XSFacet.FACET_ENUMERATION);
            List<DisplayableValueImpl<T>> enumValues = new ArrayList<DisplayableValueImpl<T>>(
                    enumerations.size());
            for (XSFacet facet : enumerations) {
                String value = facet.getValue().value;
                Element descriptionE = SchemaProcessorUtil.getAnnotationElement(facet.getAnnotation(),
                        SCHEMA_DOCUMENTATION);
                Element appInfo = SchemaProcessorUtil.getAnnotationElement(facet.getAnnotation(),
                        SCHEMA_APP_INFO);
                Element valueE = null;
                if (appInfo != null) {
                    NodeList list = appInfo.getElementsByTagNameNS(
                            PrismConstants.A_LABEL.getNamespaceURI(),
                            PrismConstants.A_LABEL.getLocalPart());
                    if (list.getLength() != 0) {
                        valueE = (Element) list.item(0);
                    }
                }
                String label = null;
                if (valueE != null) {
                    label = valueE.getTextContent();
                } else {
                    label = value;
                }
                DisplayableValueImpl<T> edv = null;
                Class compileTimeClass = prismContext.getSchemaRegistry().getCompileTimeClass(typeName);
                if (ctd != null && !ctd.isRuntimeSchema() && compileTimeClass != null) {

                    String fieldName = null;
                    for (Field field : compileTimeClass.getDeclaredFields()) {
                        XmlEnumValue xmlEnumValue = field.getAnnotation(XmlEnumValue.class);
                        if (xmlEnumValue != null && xmlEnumValue.value() != null
                                && xmlEnumValue.value().equals(value)) {
                            fieldName = field.getName();
                        }

                    }
                    if (fieldName != null) {
                        T enumValue = (T) Enum.valueOf((Class<Enum>) compileTimeClass, fieldName);
                        edv = new DisplayableValueImpl(enumValue, label,
                                descriptionE != null ? descriptionE.getTextContent() : null);
                    } else {
                        edv = new DisplayableValueImpl(value, label,
                                descriptionE != null ? descriptionE.getTextContent() : null);
                    }


                } else {
                edv = new DisplayableValueImpl(value, label,
                        descriptionE != null ? descriptionE.getTextContent() : null);
                }
                enumValues.add(edv);

            }
            if (enumValues != null && !enumValues.isEmpty()) {
                return enumValues;
            }

        }
    }
    return null;
}