Author: fdesbois Date: 2009-05-04 15:57:22 +0000 (Mon, 04 May 2009) New Revision: 497 Added: eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelType.java Modified: eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelGenerator.java Log: Correction refactor sur methode generate : ajout d'une enum pour remplacer les instanceof Modified: eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelGenerator.java =================================================================== --- eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelGenerator.java 2009-05-04 14:18:51 UTC (rev 496) +++ eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelGenerator.java 2009-05-04 15:57:22 UTC (rev 497) @@ -301,20 +301,25 @@ this.model = model; String filename = getFilenameForModel(model); - generateFromElement(model, destDir, filename); + generateFromElement(model, destDir, filename, + ObjectModelType.OBJECT_MODEL); } // generateFromClassifier - generateFromElements(model.getClassifiers(), destDir); + generateFromElements(model.getClassifiers(), destDir, + ObjectModelType.OBJECT_MODEL_CLASSIFIER); // generateFromInterface - generateFromElements(model.getInterfaces(), destDir); + generateFromElements(model.getInterfaces(), destDir, + ObjectModelType.OBJECT_MODEL_INTERFACE); // generateFromClass - generateFromElements(model.getClasses(), destDir); + generateFromElements(model.getClasses(), destDir, + ObjectModelType.OBJECT_MODEL_CLASS); // generateFromEnumeration - generateFromElements(model.getEnumerations(), destDir); + generateFromElements(model.getEnumerations(), destDir, + ObjectModelType.OBJECT_MODEL_ENUMERATION); } /** @@ -323,25 +328,31 @@ * ObjectModelEnumeration. * Deux méthodes dépendent du type et peuvent être surchargées : * getFilenameForXXX et generateFromXXX (XXX étant un type prédéfini pour une méthode existante). + * + * @see ObjectModelType + * * @param elements Collection d'éléments d'un des types ci-dessus * @param destDir dossier de destination pour le fichier généré + * @param type type explicite d'ObjectModel */ - private void generateFromElements(Collection<? extends ObjectModelElement> elements, File destDir) { + private void generateFromElements(Collection<? extends ObjectModelElement> elements, File destDir, + ObjectModelType type) { for (ObjectModelElement element : elements) { String filename = ""; // Filename depends on type of element (Classifier, Class, Interface or Enumeration) - if (element instanceof ObjectModelClassifier) { - filename = getFilenameForClassifier((ObjectModelClassifier)element); - } else if (element instanceof ObjectModelClass) { - filename = getFilenameForClass((ObjectModelClass)element); - } else if (element instanceof ObjectModelInterface) { - filename = getFilenameForInterface((ObjectModelInterface)element); - } else if (element instanceof ObjectModelEnumeration) { - filename = getFilenameForEnumeration((ObjectModelEnumeration)element); + switch (type) { + case OBJECT_MODEL_CLASSIFIER: + filename = getFilenameForClassifier((ObjectModelClassifier)element); break; + case OBJECT_MODEL_INTERFACE: + filename = getFilenameForInterface((ObjectModelInterface)element); break; + case OBJECT_MODEL_CLASS: + filename = getFilenameForClass((ObjectModelClass)element); break; + case OBJECT_MODEL_ENUMERATION: + filename = getFilenameForEnumeration((ObjectModelEnumeration)element); } - generateFromElement(element, destDir, filename); + generateFromElement(element, destDir, filename, type); } } @@ -350,11 +361,16 @@ * Types possibles : ObjectModel, ObjectModelClassifier, ObjectModelClass, * ObjectModelInterface et ObjectModelEnumeration. * La méthode generateFromXXX dépend du type d'élément et peut être surchargée. + * + * @see ObjectModelType + * * @param element element à généré * @param destDir dossier de destination * @param filename nom du fichier de sortie + * @param type type d'ObjectModel */ - private void generateFromElement(Object element, File destDir, String filename) { + private void generateFromElement(Object element, File destDir, String filename, + ObjectModelType type) { File outputFile = getDestinationFile(destDir, filename); if (!getOverwrite() && isNewerThanSource(outputFile)) { @@ -370,18 +386,48 @@ try { StringWriter out = new StringWriter(); MonitorWriter monitorOut = new MonitorWriter(out); - + /*if(log.isDebugEnabled()) { + log.debug("Instanceof: "+element.getClass().getName()); + } + System.out.println("## Instanceof: "+element.getClass().getName()); // Specific generation depends on element type if (element instanceof ObjectModel) { + if (log.isDebugEnabled()) { + log.debug("Instanceof ObjectModel"); + } generateFromModel(monitorOut,(ObjectModel)element); } else if (element instanceof ObjectModelClassifier) { + if (log.isDebugEnabled()) { + log.debug("Instanceof ObjectModelClassifier"); + } generateFromClassifier(monitorOut, (ObjectModelClassifier)element); } else if (element instanceof ObjectModelClass) { + if (log.isDebugEnabled()) { + log.debug("Instanceof ObjectModelClass"); + } generateFromClass(monitorOut, (ObjectModelClass)element); } else if (element instanceof ObjectModelInterface) { + if (log.isDebugEnabled()) { + log.debug("Instanceof ObjectModelInterface"); + } generateFromInterface(monitorOut, (ObjectModelInterface)element); } else if (element instanceof ObjectModelEnumeration) { + if (log.isDebugEnabled()) { + log.debug("Instanceof ObjectModelEnumeration"); + } generateFromEnumeration(monitorOut, (ObjectModelEnumeration)element); + }*/ + switch (type) { + case OBJECT_MODEL: + generateFromModel(monitorOut,(ObjectModel)element); break; + case OBJECT_MODEL_CLASSIFIER: + generateFromClassifier(monitorOut, (ObjectModelClassifier)element); break; + case OBJECT_MODEL_INTERFACE: + generateFromInterface(monitorOut, (ObjectModelInterface)element); break; + case OBJECT_MODEL_CLASS: + generateFromClass(monitorOut, (ObjectModelClass)element); break; + case OBJECT_MODEL_ENUMERATION: + generateFromEnumeration(monitorOut, (ObjectModelEnumeration)element); } write(outputFile, monitorOut); Added: eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelType.java =================================================================== --- eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelType.java (rev 0) +++ eugene/trunk/src/main/java/org/nuiton/eugene/ObjectModelType.java 2009-05-04 15:57:22 UTC (rev 497) @@ -0,0 +1,35 @@ +/* *##% Eugene + * Copyright (C) 2004 - 2009 CodeLutin + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. ##%*/ + +package org.nuiton.eugene; + +/** + * Enumeration for ObjectModelGenerator. + * Contains all types available for generating specific ObjectModelElement file. + * Needed because of inheritance between class, interface and classifier. + * Method instanceof (previously used) is inadequat so expliciting the ObjectModel type is much better. + * + * Created: may 4th 2009 + * + * @author Florian DESBOIS <fdesbois@codelutin.com> + * + * @version $Revision: 496 $ + */ +enum ObjectModelType { + OBJECT_MODEL, OBJECT_MODEL_ENUMERATION, OBJECT_MODEL_CLASSIFIER, + OBJECT_MODEL_CLASS, OBJECT_MODEL_INTERFACE +}