org.mapstruct.ap.internal.prism.BeanMappingPrism Maven / Gradle / Ivy

Go to download
package org.mapstruct.ap.internal.prism;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.VariableElement;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.type.TypeMirror;
import net.java.dev.hickory.prism.internal.*;
import java.util.HashMap;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.ElementFilter;
/** A Prism representing an {@code @org.mapstruct.BeanMapping} annotation. 
  */ 
public class BeanMappingPrism {
    /** store prism value of resultType */
    private TypeMirror _resultType;

    /** store prism value of qualifiedBy */
    private List _qualifiedBy;

    /** store prism value of qualifiedByName */
    private List _qualifiedByName;

    /** store prism value of nullValueMappingStrategy */
    private String _nullValueMappingStrategy;

    /**
      * An instance of the Values inner class whose
      * methods return the AnnotationValues used to build this prism. 
      * Primarily intended to support using Messager.
      */
    public final Values values;
    /** Return a prism representing the {@code @org.mapstruct.BeanMapping} annotation on 'e'. 
      * similar to {@code e.getAnnotation(org.mapstruct.BeanMapping.class)} except that 
      * an instance of this class rather than an instance of {@code org.mapstruct.BeanMapping}
      * is returned.
      */
    public static BeanMappingPrism getInstanceOn(Element e) {
        AnnotationMirror m = getMirror("org.mapstruct.BeanMapping",e);
        if(m == null) return null;
        return getInstance(m);
   }

    /** Return a prism of the {@code @org.mapstruct.BeanMapping} annotation whose mirror is mirror. 
      */
    public static BeanMappingPrism getInstance(AnnotationMirror mirror) {
        return new BeanMappingPrism(mirror);
    }

    private BeanMappingPrism(AnnotationMirror mirror) {
        for(ExecutableElement key : mirror.getElementValues().keySet()) {
            memberValues.put(key.getSimpleName().toString(),mirror.getElementValues().get(key));
        }
        for(ExecutableElement member : ElementFilter.methodsIn(mirror.getAnnotationType().asElement().getEnclosedElements())) {
            defaults.put(member.getSimpleName().toString(),member.getDefaultValue());
        }
        _resultType = getValue("resultType",TypeMirror.class);
        _qualifiedBy = getArrayValues("qualifiedBy",TypeMirror.class);
        _qualifiedByName = getArrayValues("qualifiedByName",String.class);
        VariableElement nullValueMappingStrategyMirror = getValue("nullValueMappingStrategy",VariableElement.class);
        valid = valid && nullValueMappingStrategyMirror != null;
        _nullValueMappingStrategy = nullValueMappingStrategyMirror == null ? null : nullValueMappingStrategyMirror.getSimpleName().toString();
        this.values = new Values(memberValues);
        this.mirror = mirror;
        this.isValid = valid;
    }

    /** 
      * Returns a TypeMirror representing the value of the {@code java.lang.Class resultType()} member of the Annotation.
      * @see org.mapstruct.BeanMapping#resultType()
      */ 
    public TypeMirror resultType() { return _resultType; }

    /** 
      * Returns a List representing the value of the {@code qualifiedBy()} member of the Annotation.
      * @see org.mapstruct.BeanMapping#qualifiedBy()
      */ 
    public List qualifiedBy() { return _qualifiedBy; }

    /** 
      * Returns a List representing the value of the {@code qualifiedByName()} member of the Annotation.
      * @see org.mapstruct.BeanMapping#qualifiedByName()
      */ 
    public List qualifiedByName() { return _qualifiedByName; }

    /** 
      * Returns a String representing the value of the {@code org.mapstruct.NullValueMappingStrategy nullValueMappingStrategy()} member of the Annotation.
      * @see org.mapstruct.BeanMapping#nullValueMappingStrategy()
      */ 
    public String nullValueMappingStrategy() { return _nullValueMappingStrategy; }

    /**
      * Determine whether the underlying AnnotationMirror has no errors.
      * True if the underlying AnnotationMirror has no errors.
      * When true is returned, none of the methods will return null.
      * When false is returned, a least one member will either return null, or another
      * prism that is not valid.
      */
    public final boolean isValid;
    
    /**
      * The underlying AnnotationMirror of the annotation
      * represented by this Prism. 
      * Primarily intended to support using Messager.
      */
    public final AnnotationMirror mirror;
    /**
      * A class whose members corespond to those of org.mapstruct.BeanMapping
      * but which each return the AnnotationValue corresponding to
      * that member in the model of the annotations. Returns null for
      * defaulted members. Used for Messager, so default values are not useful.
      */
    public static class Values {
       private Map values;
       private Values(Map values) {
           this.values = values;
       }    
       /** Return the AnnotationValue corresponding to the resultType() 
         * member of the annotation, or null when the default value is implied.
         */
       public AnnotationValue resultType(){ return values.get("resultType");}
       /** Return the AnnotationValue corresponding to the qualifiedBy() 
         * member of the annotation, or null when the default value is implied.
         */
       public AnnotationValue qualifiedBy(){ return values.get("qualifiedBy");}
       /** Return the AnnotationValue corresponding to the qualifiedByName() 
         * member of the annotation, or null when the default value is implied.
         */
       public AnnotationValue qualifiedByName(){ return values.get("qualifiedByName");}
       /** Return the AnnotationValue corresponding to the nullValueMappingStrategy() 
         * member of the annotation, or null when the default value is implied.
         */
       public AnnotationValue nullValueMappingStrategy(){ return values.get("nullValueMappingStrategy");}
    }
    private Map defaults = new HashMap(10);
    private Map memberValues = new HashMap(10);
    private boolean valid = true;

    private  T getValue(String name, Class clazz) {
        T result = BeanMappingPrism.getValue(memberValues,defaults,name,clazz);
        if(result == null) valid = false;
        return result;
    } 

    private  List getArrayValues(String name, final Class clazz) {
        List result = BeanMappingPrism.getArrayValues(memberValues,defaults,name,clazz);
        if(result == null) valid = false;
        return result;
    }
    private static AnnotationMirror getMirror(String fqn, Element target) {
        for (AnnotationMirror m :target.getAnnotationMirrors()) {
            CharSequence mfqn = ((TypeElement)m.getAnnotationType().asElement()).getQualifiedName();
            if(fqn.contentEquals(mfqn)) return m;
        }
        return null;
    }
    private static  T getValue(Map memberValues, Map defaults, String name, Class clazz) {
        AnnotationValue av = memberValues.get(name);
        if(av == null) av = defaults.get(name);
        if(av == null) {
            return null;
        }
        if(clazz.isInstance(av.getValue())) return clazz.cast(av.getValue());
        return null;
    }
    private static  List getArrayValues(Map memberValues, Map defaults, String name, final Class clazz) {
        AnnotationValue av = memberValues.get(name);
        if(av == null) av = defaults.get(name);
        if(av == null) {
            return null;
        }
        if(av.getValue() instanceof List) {
            List result = new ArrayList();
            for(AnnotationValue v : getValueAsList(av)) {
                if(clazz.isInstance(v.getValue())) {
                    result.add(clazz.cast(v.getValue()));
                } else{
                    return null;
                }
            }
            return result;
        } else {
            return null;
        }
    }
    @SuppressWarnings("unchecked")
    private static List getValueAsList(AnnotationValue av) {
        return (List)av.getValue();
    }
}