com.moon.mapping.processing.MappingProcessor Maven / Gradle / Ivy

Go to download
package com.moon.mapping.processing;

import com.google.auto.service.AutoService;
import com.moon.mapping.annotation.MappingFor;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import java.io.IOException;
import java.util.*;

import static com.moon.mapping.processing.ProcessUtils.toPropertiesMap;

/**
 * @author moonsky
 */
@AutoService(Processor.class)
public class MappingProcessor extends AbstractProcessor {

    private final static String SUPPORTED_TYPE = MappingFor.class.getName();

    @Override
    public SourceVersion getSupportedSourceVersion() { return SourceVersion.RELEASE_8; }

    @Override
    public Set getSupportedAnnotationTypes() {
        Set types = new HashSet<>();
        types.add(SUPPORTED_TYPE);
        return types;
    }

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        EnvUtils.initialize(processingEnv);
        super.init(processingEnv);
    }

    private void doWriteJavaFile(List models) throws IOException {
        Filer filer = EnvUtils.getEnv().getFiler();
        for (MappingWriter model : models) {
            model.writeJavaFile(filer);
        }
        MappingWriter.forAutoConfig(filer, models);
    }

    @Override
    public boolean process(
        Set annotations, RoundEnvironment roundEnv
    ) {
        List models = getMappingModels(annotations, roundEnv);
        if (!models.isEmpty()) {
            try {
                doWriteJavaFile(models);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    private List getMappingModels(Set annotations, RoundEnvironment env) {
        final List models = new ArrayList<>();
        for (TypeElement annotation : annotations) {
            if (annotation.getQualifiedName().contentEquals(SUPPORTED_TYPE)) {
                for (Element element : env.getElementsAnnotatedWith(MappingFor.class)) {
                    if (DetectUtils.isMappableElement(element)) {
                        models.add(onAnnotatedClass((TypeElement) element));
                    }
                }
            }
        }
        return models;
    }

    private MappingWriter onAnnotatedClass(final TypeElement thisElement) {
        final Elements utils = EnvUtils.getUtils();
        final Map mappingForDetailsMap = new HashMap<>(4);
        final Collection classes = ProcessUtils.getMappingForClasses(thisElement);
        BasicDefinition thisDefined = toPropertiesMap(thisElement);
        MappingWriter writable = new MappingWriter(thisDefined, mappingForDetailsMap);
        if (classes.isEmpty()) {
            return writable;
        }
        for (String thatClassname : classes) {
            TypeElement target = utils.getTypeElement(thatClassname);
            if (!DetectUtils.isMappableElement(target)) {
                continue;
            }
            mappingForDetailsMap.put(thatClassname, toPropertiesMap(target));
        }
        return writable;
    }
}