Author: fdesbois Date: 2009-11-13 09:52:04 +0100 (Fri, 13 Nov 2009) New Revision: 713 Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/Transformer.java Log: Add javadoc for Transformer Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java 2009-11-12 20:29:10 UTC (rev 712) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java 2009-11-13 08:52:04 UTC (rev 713) @@ -32,6 +32,10 @@ * <p/> * Created: 28 oct. 2009 * + * + * L'initialisation du modèle de sortie et du générateur de sortie associée, + * se fait dans la superclass grâce à la méthode init. + * * @author fdesbois * @version $Revision$ * <p/> @@ -44,7 +48,23 @@ public ObjectModelTransformer() { super(); } - + + /** + * Le model associé au transformer est le model d'entree. Le modele de sortie + * peut etre initialiser via la methode {@link org.nuiton.eugene.Transformer#initOutputModel()}. + * Il est également possible de surcharger la methode {@link #debugOutputModel()} + * pour verifier le resultat de la transformation. + * Par defaut la methode appelle la methode + * {@link #transformFromModel(ObjectModel)} puis boucle sur chaque + * class en appelant la methode + * {@link #transformFromClass(ObjectModelClass)} puis boucle sur chaque + * interface en appelant a methode + * {@link #transformFromInterface(ObjectModelInterface)} et enfin sur chaque + * enumeration en appelant la methode + * {@link #transformFromEnumeration(ObjectModelEnumeration)} + * + * @param model inputModel to transform + */ @Override public void transform(ObjectModel model) { Modified: branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/Transformer.java =================================================================== --- branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/Transformer.java 2009-11-12 20:29:10 UTC (rev 712) +++ branches/eugene-2.0/eugene/src/main/java/org/nuiton/eugene/Transformer.java 2009-11-13 08:52:04 UTC (rev 713) @@ -23,7 +23,6 @@ import java.io.File; import java.io.IOException; -import java.util.List; import java.util.Properties; import org.nuiton.eugene.models.Model; @@ -42,16 +41,35 @@ */ public abstract class Transformer<I extends Model, O extends Model> extends Generator<I> { + /** + * Output generator, to generate files from Output model. Could be an other Transformer. + */ protected Generator<O> outputGenerator; + /** + * Output model. + */ protected O outputModel; + /** + * Properties for output generator. + */ protected Properties outputProperties; public Transformer() { super(); } + /** + * Initialization of the Transformer : + * <pre> + * - initOutputModel : default, do nothing + * - initOutputGenerator : must be override to instanciate output Generator + * - initOutputModel : must be override to instanciate output Model + * </pre> + * @param model input model + * @since 2.0.0 + */ protected void init(I model) { this.model = initInputModel(model); this.outputGenerator = initOutputGenerator(); @@ -59,12 +77,31 @@ this.outputModel = initOutputModel(); } + /** + * Initialization of the Input model. By default, this method do nothing. You have + * to override it if you want to do some transformation of the input model. + * @param model input Model from Reader + * @return the input Model + * @since 2.0.0 + */ protected I initInputModel(I model) { return model; } + /** + * Initialization of the Output generator. Must be override to instanciate the Generator that will + * make the generation of the Output model. + * @return the output generator + * @since 2.0.0 + */ protected abstract Generator<O> initOutputGenerator(); + /** + * Initialization of the Output model. Must be override to instanciate and initialize the output model. + * For ObjectModel you can use, ObjectModelBuilder to build easily an empty ObjectModel. + * @return the output model + * @since 2.0.0 + */ protected abstract O initOutputModel(); @Override @@ -72,6 +109,11 @@ this.outputProperties = outputProperties; } + /** + * Output properties for output generator. Initially set from build configuration. + * @return output properties + * @since 2.0.0 + */ protected Properties getOutputProperties() { if (outputProperties == null) { outputProperties = new Properties(); @@ -87,6 +129,12 @@ return this.outputModel; } + /** + * Old method from previous EUGene 1.0.1 version. Used before creation of ModelReader. + * @param file + * @param destDir + * @deprecated no need to manage list of files in input, prefer use input model. + */ @Override @Deprecated public void generate(File[] file, File destDir) { @@ -97,22 +145,14 @@ /** - * Le model associé au transformer est le model d'entree. Le modele de sortie - * peut etre initialiser via la methode {@link #initOutputModel()}. Il est également - * possible de surcharger la methode {@link #debugOutputModel()} pour verifier le resultat - * de la transformation. - * Par defaut la methode appelle la methode - * {@link #transformFromModel(ObjectModel)} puis boucle sur chaque - * class en appelant la methode - * {@link #transformFromClass(ObjectModelClass)} puis boucle sur chaque - * interface en appelant a methode - * {@link #transformFromInterface(ObjectModelInterface)} et enfin sur chaque - * enumeration en appelant la methode - * {@link #transformFromEnumeration(ObjectModelEnumeration)} - * - * @param model inputModel to transform - * @param destDir destination folder for generation after transformation + * Transform an input model and use destination directory to put generated files for output generator. + * This method initialize the transformer with ${@link #init(org.nuiton.eugene.models.Model) } method then + * transform the input model into an other model with ${@link #transform(org.nuiton.eugene.models.Model) method + * and finally generate from the output model, using the output generator and the destination directory. + * @param model input model to transform and generate + * @param destDir destination directory to put generated files * @throws IOException + * @since 2.0.0 */ @Override public void generate(I model, File destDir) throws IOException { @@ -121,5 +161,12 @@ getOutputGenerator().generate(getOutputModel(), destDir); } + /** + * Method to override for the transformation. Initialization (InputModel, OutputModel, OutputGenerator) + * is made before transformation calling. This method only transform an input model into an output model. + * No generation is done neither outputGenerator call. + * @param model input model to transform + * @since 2.0.0 + */ public abstract void transform(I model); }