org.nuiton.eugene.AbstractMetaTransformer Maven / Gradle / Ivy

Go to download
package org.nuiton.eugene;

import org.nuiton.eugene.models.Model;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Abstract meta transformer which contains some templates to apply to an incoming model.
 *
 * Using the {@link #getExcludeTemplates()} to restrict use of some templates.
 * 
 * Created: 20 déc. 2009
 *
 * @author Tony Chemit  Copyright Code Lutin
 * @version $Revision: 777 $
 *          
 *          Mise a jour: $Date: 2009-12-20 17:27:20 +0100 (dim., 20 déc. 2009) $ par :
 *          $Author: tchemit $
 * @since 2.0.0
 */
public abstract class AbstractMetaTransformer extends AbstractGenerator {

    private final Class>[] transformers;

    public AbstractMetaTransformer(Class>... transformers) {
        this.transformers = transformers;
    }

    protected abstract boolean validateModel(M model);

    @Override
    public final void generate(File[] file, File destDir) {
        throw new UnsupportedOperationException("Transformer does not implements any longer this deprecated method");
    }

    @Override
    public void applyTemplate(M model, File destDir) throws IOException {

        boolean isValid = validateModel(model);
        if (!isValid) {

            //On n'empeche pas la génération si le modèle n'est pas valide

            return;
        }

        List> templates = getTemplates();

        for (Template template : templates) {
            // log
            if (log.isDebugEnabled()) {
                log.debug("call template : " + template.getClass().getSimpleName());
            }
            template.applyTemplate(model, destDir);
        }
    }

    protected List> getTemplates() {
        List> result = new ArrayList>();
        for (Class> generatorClass : getTransformers()) {
            Template generator;
            if (getExcludeTemplates().contains(generatorClass.getName())) {
                // exclude generator
                log.info("exclude generator " + generatorClass);
                continue;
            }
            try {
                generator = generatorClass.newInstance();

                // init template

                if (generator instanceof AbstractGenerator) {
                    ((AbstractGenerator) generator).setParent(this);
                }
                if (generator instanceof Transformer) {
                    generator.setProperties(properties);
                }

                // will use it
                result.add(generator);
            } catch (Exception e) {
                // should never happens
                if (log.isErrorEnabled()) {
                    log.error("An error occurs when generating persistence", e);
                }
                throw new RuntimeException(e);
            }
        }
        return result;
    }

    public Class>[] getTransformers() {
        return transformers;
    }
}