com.grosner.processor.model.ProcessorManager Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of DBFlow-Compiler Show documentation
DBFlow
The newest version!
package com.grosner.processor.model;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.grosner.processor.definition.*;
import com.grosner.processor.handler.BaseContainerHandler;
import com.grosner.processor.handler.Handler;
import com.grosner.processor.writer.DatabaseWriter;

import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import javax.tools.Diagnostic;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Author: andrewgrosner
 * Contributors: { }
 * Description:
 */
public class ProcessorManager implements Handler{

    private ProcessingEnvironment mProcessingEnv;

    private List mUniqueDatabases = Lists.newArrayList();

    private Map mModelToDatabaseMap = Maps.newHashMap();

    private Map mTypeConverters = Maps.newHashMap();

    private Map> mModelContainers = Maps.newHashMap();

    private Map> mTableDefinitions = Maps.newHashMap();

    private Map> mModelViewDefinition = Maps.newHashMap();

    private Map>> mMigrations = Maps.newHashMap();

    private List mManagerWriters = Lists.newArrayList();

    private List mHandlers = new ArrayList<>();

    public ProcessorManager(ProcessingEnvironment processingEnv) {
        mProcessingEnv = processingEnv;
    }

    public void addHandlers(BaseContainerHandler...containerHandlers) {
        for(BaseContainerHandler containerHandler: containerHandlers) {
            if(!mHandlers.contains(containerHandler)) {
                mHandlers.add(containerHandler);
            }
        }
    }

    public Messager getMessager() {
        return mProcessingEnv.getMessager();
    }

    public Types getTypeUtils() {
        return mProcessingEnv.getTypeUtils();
    }

    public Elements getElements() {
        return mProcessingEnv.getElementUtils();
    }

    public ProcessingEnvironment getProcessingEnvironment() {
        return mProcessingEnv;
    }

    public void addDatabase(String database) {
        if(!mUniqueDatabases.contains(database)) {
            mUniqueDatabases.add(database);
        }
    }

    public boolean hasOneDatabase() {
        return mUniqueDatabases.size() == 1;
    }

    public void addFlowManagerWriter(DatabaseWriter databaseWriter) {
        mManagerWriters.add(databaseWriter);
    }

    public List getManagerWriters() {
        return mManagerWriters;
    }

    public void addTypeConverterDefinition(TypeConverterDefinition definition) {
        mTypeConverters.put(definition.getModelClassQualifiedName(), definition);
    }

    public TypeConverterDefinition getTypeConverterDefinition(TypeElement typeElement) {
        return mTypeConverters.get(typeElement.getQualifiedName().toString());
    }

    public void addModelToDatabase(String modelName, String databaseName) {
        addDatabase(databaseName);
        mModelToDatabaseMap.put(modelName, databaseName);
    }

    public String getDatabase(String modelName) {
        return mModelToDatabaseMap.get(modelName);
    }

    public void addModelContainerDefinition(ModelContainerDefinition modelContainerDefinition) {
        String modelClassName = modelContainerDefinition.element.getSimpleName().toString();
        Map modelContainerDefinitionMap = mModelContainers.get(getDatabase(modelClassName));
        if(modelContainerDefinitionMap == null) {
            modelContainerDefinitionMap = Maps.newHashMap();
            mModelContainers.put(getDatabase(modelClassName), modelContainerDefinitionMap);
        }
        modelContainerDefinitionMap.put(modelContainerDefinition.getModelClassQualifiedName(), modelContainerDefinition);
    }

    public ModelContainerDefinition getModelContainerDefinition(String databaseName, TypeElement typeElement) {
        return mModelContainers.get(databaseName).get(typeElement.getQualifiedName().toString());
    }

    public void addTableDefinition(TableDefinition modelContainerDefinition) {
        Map tableDefinitionMap = mTableDefinitions.get(modelContainerDefinition.databaseName);
        if(tableDefinitionMap == null) {
            tableDefinitionMap = Maps.newHashMap();
            mTableDefinitions.put(modelContainerDefinition.databaseName, tableDefinitionMap);
        }
        tableDefinitionMap.put(modelContainerDefinition.element.asType().toString(), modelContainerDefinition);
    }

    public TableDefinition getTableDefinition(String databaseName, TypeElement typeElement) {
        return mTableDefinitions.get(databaseName).get(typeElement.getQualifiedName().toString());
    }

    public void addModelViewDefinition(ModelViewDefinition modelViewDefinition) {
        Map modelViewDefinitionMap = mModelViewDefinition.get(modelViewDefinition.databaseName);
        if(modelViewDefinitionMap == null) {
            modelViewDefinitionMap = Maps.newHashMap();
            mModelViewDefinition.put(modelViewDefinition.databaseName, modelViewDefinitionMap);
        }
        modelViewDefinitionMap.put(modelViewDefinition.element.asType().toString(), modelViewDefinition);
    }

    public ModelViewDefinition getModelViewDefinition(String databaseName, TypeElement typeElement) {
        return mModelViewDefinition.get(databaseName).get(typeElement.getQualifiedName().toString());
    }

    public Set getTypeConverters() {
        return Sets.newHashSet(mTypeConverters.values());
    }

    public Set getModelContainers(String databaseName) {
        Map modelContainerDefinitionMap = mModelContainers.get(databaseName);
        if(modelContainerDefinitionMap!= null) {
            return  Sets.newHashSet(mModelContainers.get(databaseName).values());
        }
        return Sets.newHashSet();
    }

    public Set getTableDefinitions(String databaseName) {
        Map tableDefinitionMap = mTableDefinitions.get(databaseName);
        if(tableDefinitionMap != null) {
            return Sets.newHashSet(mTableDefinitions.get(databaseName).values());
        }
        return Sets.newHashSet();
    }

    public Set getModelViewDefinitions(String databaseName) {
        Map modelViewDefinitionMap = mModelViewDefinition.get(databaseName);
        if(modelViewDefinitionMap != null) {
            return Sets.newHashSet(mModelViewDefinition.get(databaseName).values());
        } else {
            return Sets.newHashSet();
        }
    }

    public void addMigrationDefinition(MigrationDefinition migrationDefinition) {
        Map> migrationDefinitionMap = mMigrations.get(migrationDefinition.databaseName);
        if(migrationDefinitionMap == null) {
            migrationDefinitionMap = Maps.newHashMap();
            mMigrations.put(migrationDefinition.databaseName, migrationDefinitionMap);
        }

        List migrationDefinitions = migrationDefinitionMap.get(migrationDefinition.version);
        if(migrationDefinitions == null) {
            migrationDefinitions = Lists.newArrayList();
            migrationDefinitionMap.put(migrationDefinition.version, migrationDefinitions);
        }

        if(!migrationDefinitions.contains(migrationDefinition)) {
            migrationDefinitions.add(migrationDefinition);
        }
    }

    public Map> getMigrationsForDatabase(String databaseName) {
        Map> migrationDefinitions = mMigrations.get(databaseName);
        if(migrationDefinitions != null) {
            return migrationDefinitions;
        } else {
            return Maps.newHashMap();
        }
    }

    public void logError(String error, Object...args) {
        getMessager().printMessage(Diagnostic.Kind.ERROR, String.format(error, args));
    }

    @Override
    public void handle(ProcessorManager processorManager, RoundEnvironment roundEnvironment) {
        for(BaseContainerHandler containerHandler: mHandlers) {
            containerHandler.handle(processorManager, roundEnvironment);
        }
    }
}