|
|
What this is
This file is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Other links
The source code
// $Id: GeneratorPHP4.java,v 1.13 2004/10/03 17:59:19 mvw Exp $
// Copyright (c) 2004 The Regents of the University of California. All
// Rights Reserved. Permission to use, copy, modify, and distribute this
// software and its documentation without fee, and without a written
// agreement is hereby granted, provided that the above copyright notice
// and this paragraph appear in all copies. This software program and
// documentation are copyrighted by The Regents of the University of
// California. The software program and documentation are supplied "AS
// IS", without any accompanying services from The Regents. The Regents
// does not warrant that the operation of the program will be
// uninterrupted or error-free. The end-user understands that the program
// was developed for research purposes and is advised not to rely
// exclusively on the program for any reason. IN NO EVENT SHALL THE
// UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
// SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
// ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
// THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
// PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
// CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
// UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
package org.argouml.language.php.generator;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.rmi.server.UID;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeMap;
import java.util.TreeSet;
import javax.swing.Icon;
import org.apache.log4j.Logger;
import org.argouml.application.ArgoVersion;
import org.argouml.application.api.Argo;
import org.argouml.application.api.Notation;
import org.argouml.application.api.PluggableNotation;
import org.argouml.language.php.PHPDocumentor;
import org.argouml.model.ModelFacade;
import org.argouml.uml.generator.FileGenerator;
import org.argouml.uml.generator.Generator2;
/**
* Generator class for PHP 4.x source code
*
* @author Kai Schröder
* @since ArgoUML 0.15.5
*/
public class GeneratorPHP4
extends Generator2
implements PluggableNotation, FileGenerator {
/**
* Sets the indentation level to four spaces
*/
protected static final String INDENT = " ";
/**
* The name of the language this module generates source code for
*/
protected static final String LANGUAGE_NAME = "PHP";
/**
* Icon to represent this notation in the GUI
*/
protected static final Icon ICON = Argo.lookupIconResource("PHPNotation");
/**
* Info block already written to log file?
*/
protected static final TreeMap TM_INFO_BLOCK_LOGGED = new TreeMap();
/**
* The major version of the language this module generates source code for
*/
private int iLanguageMajorVersion = LANGUAGE_MAJOR_VERSION;
/**
* source section handler
*/
private static Section objSection = null;
/**
* The log4j logger to log messages to
*/
private static final Logger LOG = Logger.getLogger(GeneratorPHP4.class);
/**
* The major version of the language this module generates source code for
*/
private static final int LANGUAGE_MAJOR_VERSION = 4;
// ----- class constructors ------------------------------------------------
/**
* Zero-argument class constructor
*/
private GeneratorPHP4() {
super(Notation.makeNotation(LANGUAGE_NAME, LANGUAGE_MAJOR_VERSION
+ ".x", ICON));
logModuleInfo();
}
/**
* Class constructor
*
* @param iLangMajorVersion The major version of the language this module
* generates source code for.
*/
protected GeneratorPHP4(int iLangMajorVersion) {
super(Notation.makeNotation(LANGUAGE_NAME, iLangMajorVersion
+ ".x", ICON));
iLanguageMajorVersion = iLangMajorVersion;
logModuleInfo();
}
// ----- org.argouml.application.api.NotationProvider ----------------------
/**
* Generates extension point
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateExtensionPoint(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateExtensionPoint(MExtensionPoint modelElement)");
if (!ModelFacade.isAExtensionPoint(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, ExtensionPoint required");
}
return "generateExtensionPoint(MExtensionPoint modelElement)";
}
/**
* @see org.argouml.application.api.NotationProvider2#generateObjectFlowState(java.lang.Object)
*/
public String generateObjectFlowState(Object m) {
Object c = ModelFacade.getType(m);
if (c == null) return "";
return ModelFacade.getName(c);
}
/**
* Generates operation
*
* @param modelElement Model element to generate notation for.
* @param bAddDocs Add documentation in front of notation?
*
* @return Generated notation for model element.
*/
public String generateOperation(Object modelElement, boolean bAddDocs) {
if (!ModelFacade.isAOperation(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Operation required");
}
String sOperation = "";
if (bAddDocs) {
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(modelElement);
} catch (Exception exp) {
LOG.error("Generating operation DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sOperation += objPHPDoc.toString();
}
}
}
String sVisibility = generate(ModelFacade.getVisibility(modelElement));
if (sVisibility != null && sVisibility != "") {
sOperation += sVisibility + " ";
}
if (iLanguageMajorVersion > 4) {
/* scope */
Object ownerScope = ModelFacade.getOwnerScope(modelElement);
if (ModelFacade.CLASSIFIER_SCOPEKIND.equals(ownerScope)) {
sOperation += "static ";
}
/* changeability */
if (ModelFacade.isLeaf(modelElement)) {
sOperation += "final ";
}
/* abstractness */
if (ModelFacade.isAbstract(modelElement)) {
sOperation += "abstract ";
}
}
boolean bReturnByReference = false;
Iterator itTaggedValues = ModelFacade.getTaggedValues(modelElement);
if (itTaggedValues != null && itTaggedValues instanceof Iterator) {
while (itTaggedValues.hasNext()) {
Object objTaggedValue = itTaggedValues.next();
if (ModelFacade.getTagOfTag(objTaggedValue).equals("&")) {
if (ModelFacade.getValueOfTag(objTaggedValue)
.equals("true")) {
bReturnByReference = true;
break;
}
}
}
}
String sOperationName = NameGenerator.generate(modelElement,
iLanguageMajorVersion);
if (bReturnByReference) {
sOperationName = "&" + sOperationName;
}
sOperation += "function " + sOperationName + "(";
Collection colParameters = ModelFacade.getParameters(modelElement);
if (colParameters != null) {
Iterator itParameters = colParameters.iterator();
boolean bFirst = true;
while (itParameters.hasNext()) {
Object objParameter = itParameters.next();
if (!ModelFacade.isReturn(objParameter)) {
if (!bFirst) {
sOperation += ", ";
} else {
bFirst = false;
}
sOperation += generate(objParameter);
}
}
}
sOperation += ")";
return sOperation;
}
/**
* Generates attribute
*
* @param modelElement Model element to generate notation for.
* @param bAddDocs Add documentation in front of notation?
*
* @return Generated notation for model element.
*/
public String generateAttribute(Object modelElement, boolean bAddDocs) {
if (!ModelFacade.isAAttribute(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Attribute required");
}
String sAttribute = "";
if (bAddDocs) {
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(modelElement);
} catch (Exception exp) {
LOG.error("Generating attribute DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sAttribute += objPHPDoc.toString(INDENT);
}
}
}
String sVisibility = generate(ModelFacade.getVisibility(modelElement));
if (sVisibility != null && sVisibility != "") {
sAttribute += sVisibility + " ";
}
if (iLanguageMajorVersion > 4) {
/* scope */
Object ownerScope = ModelFacade.getOwnerScope(modelElement);
if (ModelFacade.CLASSIFIER_SCOPEKIND.equals(ownerScope)) {
sAttribute += "static ";
}
} else {
sAttribute += "var ";
}
sAttribute += "$" + NameGenerator.generate(modelElement,
iLanguageMajorVersion);
String sInitialValue = null;
Object exprInitialValue = ModelFacade.getInitialValue(modelElement);
if (exprInitialValue != null) {
sInitialValue = generateDefaultValue(
ModelFacade.getType(modelElement),
generate(exprInitialValue).trim(), false);
} else {
sInitialValue = generateDefaultValue(
ModelFacade.getType(modelElement), null, false);
}
if (sInitialValue != null && sInitialValue.length() > 0) {
sAttribute += " = " + sInitialValue;
} else {
sAttribute += "[ ";
sAttribute += (exprInitialValue != null) ? "!= null" : "null";
sAttribute += " | ";
sAttribute += generateDefaultValue(
ModelFacade.getType(modelElement),
generate(exprInitialValue).trim(), false);
sAttribute += " | ";
sAttribute += generateDefaultValue(
ModelFacade.getType(modelElement),
generate(exprInitialValue).trim(), true);
sAttribute += " ]";
}
sAttribute += ";";
return sAttribute;
}
/**
* Generates parameter
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateParameter(Object modelElement) {
if (!ModelFacade.isAParameter(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Parameter required");
}
String sParameter = "";
if (ModelFacade.isReturn(modelElement)) {
Object objType = ModelFacade.getType(modelElement);
if (ModelFacade.getName(objType).equals("void")) {
return "";
} else {
String sType = convertType(objType);
if (sType != null && sType.trim() != "") {
return "return (" + sType + ") $returnValue;";
} else {
return "return $returnValue;";
}
}
} else {
if (iLanguageMajorVersion < 5) {
// TODO: Do we really need this for PHP5?
// TODO: Implent this in ModelFacade
/* if OUT or INOUT, then pass by reference */
if (ModelFacade.getKind(modelElement).equals(
ModelFacade.INOUT_PARAMETERDIRECTIONKIND)
|| ModelFacade.getKind(modelElement).equals(
ModelFacade.OUT_PARAMETERDIRECTIONKIND)) {
sParameter += "&";
}
}
sParameter += "$" + ModelFacade.getName(modelElement);
String sDefaultValue =
generate(ModelFacade.getDefaultValue(modelElement));
if (sDefaultValue != null && sDefaultValue.length() > 0) {
sParameter += " = " + sDefaultValue;
} else {
boolean bAddDefaultValue = false;
Collection colParameters =
ModelFacade.getParameters(ModelFacade
.getBehavioralFeature(modelElement));
if (colParameters != null) {
Iterator itParameters = colParameters.iterator();
while (itParameters.hasNext()) {
Object objParameter = itParameters.next();
if (!ModelFacade.isReturn(objParameter)) {
if (!modelElement.equals(objParameter)) {
if (ModelFacade.getDefaultValue(objParameter)
!= null) {
bAddDefaultValue = true;
}
} else {
break;
}
}
}
}
if (bAddDefaultValue) {
sParameter += " = " + generateDefaultValue(
ModelFacade.getType(modelElement), null, false);
}
}
}
return sParameter;
}
/**
* Generates package
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*
* TODO: fix org.argouml.model.ModelFacade#getType
*/
public String generatePackage(Object modelElement) {
String sPackage = "";
if (!ModelFacade.isAPackage(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Package required");
}
String sPackageName =
NameGenerator.generate(modelElement, iLanguageMajorVersion);
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(modelElement);
} catch (Exception exp) {
LOG.error("Generating package DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sPackage += objPHPDoc.toString() + "\n";
}
}
Collection colElements = ModelFacade.getOwnedElements(modelElement);
if (colElements != null) {
Iterator itElements = colElements.iterator();
if (itElements != null) {
while (itElements.hasNext()) {
Object objElement = itElements.next();
if (ModelFacade.isAPackage(objElement)) {
sPackage += generate(objElement) + "\n";
} else if (ModelFacade.isAClassifier(objElement)) {
sPackage += generate(objElement) + "\n";
} else {
sPackage += "/*\n";
sPackage += "feature not supported by PHP:\n";
sPackage += "-----------------------------\n";
sPackage += generate(objElement) + "\n";
sPackage += "*/\n";
}
if (itElements.hasNext()) {
sPackage += "\n";
}
}
}
} else {
sPackage += "// this package contains no elements\n";
}
sPackage += "\n/* end of package " + sPackageName + " */";
return sPackage;
}
/**
* Generates class or interface
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateClassifier(Object modelElement) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sClassifier = "";
String sClassType = "";
if (iLanguageMajorVersion > 4) {
if (ModelFacade.isAClass(modelElement)) {
if (ModelFacade.isLeaf(modelElement)) {
sClassType = "final class";
} else {
sClassType = "class";
}
if (ModelFacade.isAbstract(modelElement)) {
sClassType = "abstract " + sClassType;
}
} else if (ModelFacade.isAInterface(modelElement)) {
sClassType = "interface";
if (ModelFacade.isLeaf(modelElement)) {
sClassType = "final " + sClassType;
}
} else {
return null;
}
} else {
if (ModelFacade.isAClass(modelElement)
|| ModelFacade.isAInterface(modelElement)) {
sClassType = "class";
} else {
return null;
}
}
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(modelElement);
} catch (Exception exp) {
LOG.error("Generating classifier DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sClassifier += objPHPDoc.toString();
}
}
String sClassName =
NameGenerator.generate(modelElement, iLanguageMajorVersion);
sClassifier += sClassType + " " + sClassName + "\n";
sClassifier += generateClassifierGeneralisations(modelElement);
sClassifier += generateClassifierSpecifications(modelElement);
sClassifier += "{\n";
sClassifier += generateClassifierAttributes(modelElement);
sClassifier += generateClassifierOperations(modelElement);
sClassifier += "\n} /* end of " + sClassType + " " + sClassName + " */";
return sClassifier;
}
/**
* Generates tagged value
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateTaggedValue(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateTaggedValue(MTaggedValue modelElement)");
if (!ModelFacade.isATaggedValue(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, TaggedValue required");
}
return "generateTaggedValue(MTaggedValue modelElement)";
}
/**
* Generates association
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateAssociation(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateExtensionPoint(MExtensionPoint modelElement)");
if (!ModelFacade.isAAssociation(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Association required");
}
return "generateAssociation(MAssociation modelElement)";
}
/**
* Generates association end
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateAssociationEnd(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateAssociationEnd(MAssociationEnd modelElement)");
if (!ModelFacade.isAAssociationEnd(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, AssociationEnd required");
}
return "generateAssociationEnd(MAssociationEnd modelElement)";
}
/**
* Genarates multiplicity
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateMultiplicity(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateMultiplicity(MMultiplicity modelElement)");
if (!ModelFacade.isAMultiplicity(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Multiplicity required");
}
return "generateMultiplicity(MMultiplicity modelElement)";
}
/**
* Generates state
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateState(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateState(MState modelElement)");
if (!ModelFacade.isAState(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, State required");
}
return "generateState(MState modelElement)";
}
/**
* Generates transition
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateTransition(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateTransition(MTransition modelElement)");
if (!ModelFacade.isATransition(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Transition required");
}
return "generateTransition(MTransition modelElement)";
}
/**
* Generates action
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateAction(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateAction(Object modelElement)");
if (!ModelFacade.isAAction(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Action required");
}
return "generateAction(Object modelElement)";
}
/**
* Generates guard
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateGuard(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateGuard(MGuard modelElement)");
if (!ModelFacade.isAGuard(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Guard required");
}
return "generateGuard(MGuard modelElement)";
}
/**
* Generates message
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateMessage(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateMessage(MMessage modelElement)");
if (!ModelFacade.isAMessage(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Message required");
}
return "generateMessage(MMessage modelElement)";
}
/**
* Generates visibility
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateVisibility(Object modelElement) {
if (!ModelFacade.isAVisibilityKind(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, VisibilityKind required");
}
if (iLanguageMajorVersion > 4) {
if (ModelFacade.PUBLIC_VISIBILITYKIND.equals(modelElement)) {
return "public";
} else if (ModelFacade.PROTECTED_VISIBILITYKIND
.equals(modelElement)) {
return "protected";
} else if (ModelFacade.PRIVATE_VISIBILITYKIND
.equals(modelElement)) {
return "private";
}
}
return "";
}
/**
* Generates the String representation for an Event.
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateEvent(Object modelElement) {
if (!ModelFacade.isAEvent(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Event required");
}
return "";
}
// --- org.argouml.uml.generator.FileGenerator -----------------------------
/**
* Generates file
*
* @param modelElement Model element to generate notation for.
* @param sPath output base directory
*
* @deprecated style break, see issue 2570
*
* @return name of generated file on success;
* null otherwise.
*
* @see org.argouml.uml.generator.FileGenerator#generateFile2(
* java.lang.Object, java.lang.String)
*/
public String generateFile2(Object modelElement, String sPath) {
return generateFile(modelElement, sPath);
}
/**
* Generates file
*
* @param modelElement Model element to generate notation for.
* @param sPath output base directory
*
* @return name of generated file on success;
* null otherwise.
*/
public String generateFile(Object modelElement, String sPath) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sFilename = NameGenerator.generateFilename(modelElement, sPath,
iLanguageMajorVersion);
if (sFilename == null || sFilename.length() == 0) {
LOG.error("Can't generate a nameless class");
return null;
}
File f = new File(sFilename);
if (f.exists()) {
LOG.info(getModuleName() + " updates " + f.getPath());
try {
updateFile(modelElement, f);
} catch (Exception exp) {
LOG.error("Update " + f.getPath() + " failed: "
+ exp.getMessage());
return null;
}
LOG.debug("Update " + f.getPath() + " successfull");
return sFilename;
}
LOG.info(getModuleName() + " creates " + f.getPath());
File fPath = new File(sPath);
if (!fPath.isDirectory()) {
if (!fPath.mkdirs()) {
LOG.error(getModuleName() + " could not make directory "
+ sPath);
return null;
}
}
if (createFile(modelElement, f)) {
LOG.debug("Creating " + f.getPath() + " successfull");
return sFilename;
} else {
LOG.error("Creating " + f.getPath() + " failed");
return null;
}
}
// ----- org.argouml.application.api.ArgoModule ----------------------------
/**
* Gets name of this module
*
* @return name of this module
*/
public final String getModuleName() {
return "Generator" + LANGUAGE_NAME.toUpperCase()
+ iLanguageMajorVersion;
}
/**
* Gets description of this module
*
* @return description of this module
*/
public final String getModuleDescription() {
return "notation and source code generator for "
+ LANGUAGE_NAME.toUpperCase() + iLanguageMajorVersion;
}
/**
* Gets version of this module
*
* @return current version of this module
*/
public String getModuleVersion() {
return "0.0.1";
}
/**
* Gets author(s) of this module
*
* @return name of author(s) of this module
*/
public final String getModuleAuthor() {
return "Kai Schr\u00F6der";
}
/**
* Gets key of this module
*
* @return key string to identify this module
*/
public final String getModuleKey() {
return "org.argouml.language." + LANGUAGE_NAME.toLowerCase()
+ iLanguageMajorVersion + ".generator";
}
// ----- org.argouml.application.api.NotationProvider ----------------------
/**
* Generates state body
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateStateBody(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateStateBody(MState modelElement)");
if (!ModelFacade.isAState(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, State required");
}
return "generateStateBody(MState modelElement)";
}
/**
* Generates association role
*
* @param modelElement Model element to generate notation for.
*
* @return Generated notation for model element.
*/
public String generateAssociationRole(Object modelElement) {
// TODO: Auto-generated method stub
LOG.debug("generateAssociationRole(MAssociationRole modelElement)");
if (!ModelFacade.isAAssociationRole(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, AssociationRole required");
}
return "generateAssociationRole(MAssociationRole modelElement)";
}
/**
* Can this module parse given object?
*
* @param obj object to parse
*
* @return false
*/
public boolean canParse(Object obj) {
// TODO: Auto-generated method stub
return false;
}
/**
* Can this module parse in general?
*
* @return false
*/
public boolean canParse() {
// TODO: Auto-generated method stub
return false;
}
// -------------------------------------------------------------------------
/**
* Logs module info block to logger
*/
protected final void logModuleInfo() {
logModuleInfo(0);
}
/**
* Logs module info block to logger
*
* @param iMinWidth Minimum block width.
*/
protected final void logModuleInfo(int iMinWidth) {
if (!TM_INFO_BLOCK_LOGGED.containsKey(this.getClass().toString())) {
StringBuffer sbHeadLine = new StringBuffer("| Module ");
sbHeadLine.append(getModuleName() + " "
+ getModuleVersion() + " |");
StringBuffer sbCopyLine =
new StringBuffer("| Copyright (c) 2004, ");
sbCopyLine.append(getModuleAuthor() + " |");
StringBuffer sbDescLine = new StringBuffer("| ");
sbDescLine.append(getModuleDescription() + " |");
if (sbHeadLine.length() > iMinWidth) {
iMinWidth = sbHeadLine.length();
}
if (sbCopyLine.length() > iMinWidth) {
iMinWidth = sbCopyLine.length();
}
if (sbDescLine.length() > iMinWidth) {
iMinWidth = sbDescLine.length();
}
String sRulerLine = "+";
for (int i = 1; i <= iMinWidth - 2; i++) sRulerLine += "-";
sRulerLine += "+";
String sEmptyLine = "";
for (int i = 1; i <= iMinWidth; i++) sEmptyLine += " ";
while (sbHeadLine.length() < iMinWidth) {
sbHeadLine.insert(sbHeadLine.length() - 2, " ");
if (sbHeadLine.length() < iMinWidth) {
sbHeadLine.insert(2, " ");
}
}
while (sbCopyLine.length() < iMinWidth) {
sbCopyLine.insert(sbCopyLine.length() - 2, " ");
}
while (sbDescLine.length() < iMinWidth) {
sbDescLine.insert(sbDescLine.length() - 2, " ");
}
LOG.info(sEmptyLine);
LOG.info(sRulerLine);
LOG.info(sbHeadLine.toString());
LOG.info(sRulerLine);
LOG.info(sbCopyLine.toString());
LOG.info("| " + sEmptyLine.substring(4) + " |");
LOG.info(sbDescLine.toString());
LOG.info(sRulerLine);
LOG.info(sEmptyLine);
TM_INFO_BLOCK_LOGGED.put(this.getClass().toString(), "true");
}
}
/**
* Converts a type model element to a PHP type
*
* @param modelElement The model element to convert to a PHP type.
*
* @return The PHP type converted from the model element.
*/
protected final String convertType(Object modelElement) {
String sName = ModelFacade.getName(modelElement).trim();
if (sName.equals("void")) return null;
if (sName.equals("char")) return "string";
if (sName.equals("boolean")) return "bool";
if (sName.equals("bool")) return "bool";
if (sName.equals("int")) return "int";
if (sName.equals("byte")) return "int";
if (sName.equals("short")) return "int";
if (sName.equals("long")) return "int";
if (sName.equals("float")) return "float";
if (sName.equals("double")) return "float";
/* user defined type string, not (java.lang.)String */
if (sName.equals("string")) return "string";
/* user defined type array */
if (sName.equals("array")) return "array";
return null;
}
/**
* Generates the default value for a type
*
* @param modelElement classifier representing a type
* @param sDefault default value
* @param bCast prefix value with cast statement
*
* @return default value with explicite cast (if needed)
*/
protected final String generateDefaultValue(Object modelElement,
String sDefault, boolean bCast) {
if (modelElement == null) return null;
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sType = convertType(modelElement);
if (sType == null) {
return "null";
} else if (sType.equals("string")) {
String sReturn = bCast ? "(string) " : "";
if (sDefault != null) {
int iFirstApos = sDefault.indexOf("'");
while (iFirstApos != -1) {
sDefault = sDefault.substring(0, iFirstApos)
+ "\\" + sDefault.substring(iFirstApos);
iFirstApos = sDefault.indexOf("'", iFirstApos + 2);
}
return sReturn + "'" + sDefault + "'";
} else {
return sReturn + "''";
}
} else if (sType.equals("bool")) {
String sReturn = bCast ? "(bool) " : "";
if (sDefault != null) {
sDefault = sDefault.trim();
if (sDefault.length() > 0) {
if (sDefault == "0") {
return sReturn + "false";
} else if (sDefault == "false") {
return sReturn + "false";
} else {
return sReturn + "true";
}
} else {
return sReturn + "false";
}
} else {
return sReturn + "false";
}
} else if (sType.equals("int")) {
String sReturn = bCast ? "(int) " : "";
if (sDefault != null && sDefault.trim().length() > 0) {
return sReturn + sDefault.trim();
} else {
return sReturn + String.valueOf(0);
}
} else if (sType.equals("float")) {
String sReturn = bCast ? "(float) " : "";
if (sDefault != null && sDefault.trim().length() > 0) {
return sReturn + sDefault.trim();
} else {
return sReturn + "0.0";
}
} else if (sType.equals("array")) {
if (sDefault != null && sDefault.trim() != "") {
return "array(" + sDefault + ")";
} else {
return "array()";
}
}
return "null";
}
/**
* Generates section for an operation element
*
* @param modelElement The model element to generate the section for.
*
* @return Generated section code for the model element.
*/
private final String generateSection(Object modelElement) {
return generateSection(modelElement, INDENT, null);
}
/**
* Generates section
*
* @param modelElement The model element to generate the section for.
* @param sIndent String to indent every section block line with.
* @param sSuffix Section identifier suffix
*
* @return Generated section code for the model element.
*/
private final String generateSection(Object modelElement, String sIndent,
String sSuffix) {
String sId = ModelFacade.getUUID(modelElement);
if (sId == null) {
sId = (new UID().toString());
ModelFacade.setUUID(modelElement, sId);
}
if (sSuffix != null && sSuffix.trim() != "") {
return Section.generate(sId + "-" + sSuffix.trim(), sIndent);
} else {
return Section.generate(sId, sIndent);
}
}
/**
* Creates new source file.
*
* @param modelElement The class or interface.
* @param file The file object to write to.
*
* @return true on success,
* false otherwise;
*/
private final boolean createFile(Object modelElement, File file) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
LOG.info(" Generating new " + file.getPath());
String sOutput = " version_compare(PHP_VERSION, '"
+ iLanguageMajorVersion + "')) {\n";
sOutput += INDENT + "die('This file was generated for PHP "
+ iLanguageMajorVersion + "');\n" + "}\n\n";
sOutput += generateRequired(modelElement);
sOutput += "/* user defined includes */\n";
sOutput += generateSection(modelElement, "", "includes") + "\n";
sOutput += "/* user defined constants */\n";
sOutput += generateSection(modelElement, "", "constants") + "\n";
sOutput += generate(modelElement);
sOutput += "\n\n?>";
boolean bReturn = true;
BufferedWriter bwOutput = null;
try {
File parentDir = new File(file.getParent());
if (!parentDir.exists()) {
parentDir.mkdirs();
}
bwOutput = new BufferedWriter(new FileWriter(file));
bwOutput.write(sOutput);
} catch (IOException exp) {
LOG.error(" Catched IOException: " + exp
+ ", for file " + file.getPath());
bReturn = false;
} finally {
try {
if (bwOutput != null) {
bwOutput.close();
}
} catch (IOException exp) {
LOG.error(" Catched IOException: " + exp
+ ", for file " + file.getPath());
bReturn = false;
}
}
return bReturn;
}
/**
* Updates the output file for a model element.
*
* @param modelElement The model element to update file for.
* @param fileOrig The original (previous) output file.
*
* @throws Exception
*/
private final void updateFile(Object modelElement, File fileOrig)
throws Exception {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
objSection = new Section();
File fileNew = new File(fileOrig.getAbsolutePath() + ".out");
File fileBackup = new File(fileOrig.getAbsolutePath() + ".bak");
LOG.debug(" Parsing sections from " + fileOrig.getPath());
objSection.read(fileOrig.getAbsolutePath());
if (fileBackup.exists()) {
LOG.debug(" Delete (old) backup " + fileBackup.getPath());
fileBackup.delete();
}
LOG.debug(" Backup " + fileOrig.getPath() + " to "
+ fileBackup.getPath());
fileOrig.renameTo(fileBackup);
if (this.createFile(modelElement, fileOrig)) {
LOG.debug(" Merging sections into " + fileNew.getPath());
objSection.write(fileOrig.getAbsolutePath(), INDENT, true);
LOG.debug(" Renaming " + fileNew.getPath()
+ " to " + fileOrig.getPath());
fileOrig.delete();
fileNew.renameTo(fileOrig);
} else {
if (fileBackup.exists()) {
LOG.debug(" Renaming (restore) " + fileBackup.getPath()
+ " to " + fileOrig.getPath());
fileBackup.renameTo(fileOrig);
}
LOG.error(" Updating " + fileOrig.getPath() + " failed");
}
}
/**
* Generates classifier attributes
*
* @param modelElement classifier
*
* @return source code for class attributes
*/
private String generateClassifierAttributes(Object modelElement) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sClsAttr = "";
if (ModelFacade.isAClass(modelElement)) {
sClsAttr += INDENT + "// --- ATTRIBUTES ---\n";
Collection colAttributes =
ModelFacade.getAttributes(modelElement);
if (colAttributes != null) {
Iterator itAttributes = colAttributes.iterator();
while (itAttributes.hasNext()) {
Object attr = itAttributes.next();
sClsAttr += "\n";
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(attr);
} catch (Exception exp) {
LOG.error("Generating attribute DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sClsAttr += objPHPDoc.toString(INDENT);
}
}
sClsAttr += INDENT + generate(attr) + "\n";
}
}
sClsAttr += "\n";
}
return sClsAttr;
}
/**
* Generates classifier generalisations
*
* @param modelElement classifier
*
* @return source code for extends part of class declaration
*/
private String generateClassifierGeneralisations(Object modelElement) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sClsGen = "";
Collection colGeneralizations =
ModelFacade.getGeneralizations(modelElement);
if (colGeneralizations != null) {
Iterator itGen = colGeneralizations.iterator();
if (itGen.hasNext()) {
if (colGeneralizations.size() == 1) {
sClsGen += INDENT + "extends ";
} else {
sClsGen += INDENT + "/* multiple generalisations not"
+ " supported by PHP: */\n";
sClsGen += INDENT + "/* extends ";
}
while (itGen.hasNext()) {
Object elmGen = ModelFacade.getParent(itGen.next());
if (elmGen != null) {
sClsGen += NameGenerator.generate(elmGen,
iLanguageMajorVersion);
if (itGen.hasNext()) {
sClsGen += ",\n" + INDENT + " ";
}
}
}
if (colGeneralizations.size() > 1) {
sClsGen += " */";
}
sClsGen += "\n";
}
}
return sClsGen;
}
/**
* Generates classifier operations
*
* @param modelElement classifier
*
* @return source code for all class methods
*/
private String generateClassifierOperations(Object modelElement) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sClsOp = "";
sClsOp += INDENT + "// --- OPERATIONS ---\n";
/* generate constructor */
Object objTaggedValue =
ModelFacade.getTaggedValue(modelElement, "constructor");
if (objTaggedValue != null) {
String sTaggedValueConstructor =
ModelFacade.getValueOfTag(objTaggedValue);
if (sTaggedValueConstructor != null
&& sTaggedValueConstructor.equals("true")) {
if (findConstructor(modelElement) == null) {
String sConstructor = null;
if (iLanguageMajorVersion < 5) {
sConstructor = "function " + NameGenerator.generate(
modelElement, iLanguageMajorVersion);
} else {
sConstructor = "public function __construct";
}
sClsOp += "\n";
sClsOp += INDENT + "/**\n";
sClsOp += INDENT + " * Class constructor\n";
sClsOp += INDENT + " *\n";
sClsOp += INDENT + " * @access public\n";
sClsOp += INDENT + " *\n";
sClsOp += INDENT + " * @return void\n";
sClsOp += INDENT + " *\n";
sClsOp += INDENT + " * @author ArgoUML "
+ ArgoVersion.getVersion() + "\n";
sClsOp += INDENT + " */\n";
sClsOp += INDENT + sConstructor + "()\n";
sClsOp += INDENT + "{\n";
sClsOp += generateSection(modelElement, INDENT,
sConstructor.substring(sConstructor.lastIndexOf(" ")));
sClsOp += INDENT + "}\n";
}
}
}
if (ModelFacade.isAClass(modelElement)) {
Collection colSpec = ModelFacade.getSpecifications(modelElement);
if (colSpec != null) {
Iterator itSpec = colSpec.iterator();
while (itSpec.hasNext()) {
Collection colIfOps =
ModelFacade.getOperations(itSpec.next());
if (colIfOps != null) {
Iterator itIfOps = colIfOps.iterator();
while (itIfOps.hasNext()) {
Object op = itIfOps.next();
sClsOp += "\n";
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(op);
} catch (Exception exp) {
LOG.error("Generating operation DocBlock "
+ "FAILED: " + exp.getMessage());
} finally {
if (objPHPDoc != null) {
sClsOp += objPHPDoc.toString(INDENT);
}
}
sClsOp += INDENT + generate(op);
sClsOp += generateMethodBody(op, true);
}
}
}
}
}
Collection colOperations = ModelFacade.getOperations(modelElement);
if (colOperations != null) {
Iterator itOperations = colOperations.iterator();
while (itOperations.hasNext()) {
Object op = itOperations.next();
sClsOp += "\n";
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(op);
} catch (Exception exp) {
LOG.error("Generating operation DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sClsOp += objPHPDoc.toString(INDENT);
}
}
sClsOp += INDENT + generate(op);
if (ModelFacade.isAClass(modelElement)) {
sClsOp += generateMethodBody(op, false);
} else {
if (iLanguageMajorVersion < 5) {
sClsOp += "\n" + INDENT + "{\n";
sClsOp += INDENT + INDENT
+ "die('abstract method called');\n";
sClsOp += INDENT + "}\n";
} else {
sClsOp += ";\n";
}
}
}
}
return sClsOp;
}
/**
* Generates classifier specifications
*
* @param modelElement The model element to generate specifications for.
*
* @return source code for implements part of class declaration
*/
private String generateClassifierSpecifications(Object modelElement) {
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
String sClsSpec = "";
if (ModelFacade.isAClass(modelElement)) {
Collection colSpecifications =
ModelFacade.getSpecifications(modelElement);
if (colSpecifications != null) {
Iterator itSpecifications = colSpecifications.iterator();
if (itSpecifications.hasNext()) {
if (iLanguageMajorVersion < 5) {
sClsSpec += INDENT + INDENT + "/* specifications are "
+ "not supported by PHP versions before 5.0 "
+ "*/\n";
}
sClsSpec += INDENT + INDENT;
if (iLanguageMajorVersion < 5) {
sClsSpec += "/* ";
}
sClsSpec += "implements ";
while (itSpecifications.hasNext()) {
Object ifSpecification = itSpecifications.next();
sClsSpec += NameGenerator.generate(ifSpecification,
iLanguageMajorVersion);
if (itSpecifications.hasNext()) {
sClsSpec += ",\n" + INDENT + INDENT + " ";
}
}
if (iLanguageMajorVersion < 5) {
sClsSpec += " */";
}
sClsSpec += "\n";
}
}
}
return sClsSpec;
}
/**
* Generates single require_once statement for class or interface
*
* @param modelElement The required class or interface.
* @param bAddDocs Add DocBlock before the require_once statement.
*
* @return single require_once statement
*/
private String generateRequireOnceStatement(Object modelElement,
boolean bAddDocs) {
String sRequired = "";
if (bAddDocs) {
PHPDocumentor objPHPDoc = null;
try {
objPHPDoc = new PHPDocumentor(modelElement,
PHPDocumentor.BLOCK_TYPE_INCLUDE);
} catch (Exception exp) {
LOG.error("Generating include DocBlock FAILED: "
+ exp.getMessage());
} finally {
if (objPHPDoc != null) {
sRequired += objPHPDoc.toString();
}
}
}
String sFilename = NameGenerator.generateFilename(modelElement,
iLanguageMajorVersion);
if (FILE_SEPARATOR != "/") {
int iFirstFS = sFilename.indexOf(FILE_SEPARATOR);
while (iFirstFS != -1) {
sFilename = sFilename.substring(0, iFirstFS) + "/"
+ sFilename.substring(iFirstFS + 1);
iFirstFS = sFilename.indexOf(FILE_SEPARATOR, iFirstFS + 1);
}
}
sRequired += "require_once('" + sFilename + "');\n";
return sRequired;
}
/**
* Generates method body for an operation element
*
* @param modelElement Model element to generate body notation for.
* @param bIgnoreAbstract Ignore abstract to generate implementations of
* abstract methods.
*
* @return Generated body notation for model element.
*
* TODO: add documentation
*/
private String generateMethodBody(Object modelElement,
boolean bIgnoreAbstract) {
if (!ModelFacade.isAOperation(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Operation required");
}
String sMethodBody = "";
if (!ModelFacade.isAbstract(modelElement) || bIgnoreAbstract) {
sMethodBody += "\n" + INDENT + "{\n";
Collection colParameters = ModelFacade.getParameters(modelElement);
if (colParameters != null) {
Iterator itParameters = colParameters.iterator();
while (itParameters.hasNext()) {
Object objParameter = itParameters.next();
if (ModelFacade.isReturn(objParameter)) {
String sReturnInit = generateDefaultValue(
ModelFacade.getType(objParameter), null, true);
String sReturnValue = generate(objParameter);
if (sReturnInit != null && sReturnValue.trim() != "") {
sMethodBody += INDENT + INDENT + "$returnValue = "
+ sReturnInit + ";\n\n";
}
sMethodBody += generateSection(modelElement);
if (sReturnValue != null && sReturnValue != "") {
sMethodBody += "\n" + INDENT + INDENT
+ sReturnValue + "\n";
}
sMethodBody += INDENT + "}\n";
break;
}
}
}
} else {
if (iLanguageMajorVersion < 5) {
sMethodBody += "\n" + INDENT + "{\n";
sMethodBody += INDENT + INDENT
+ "die('abstract method called');\n";
sMethodBody += INDENT + "}\n";
} else {
sMethodBody += ";\n";
}
}
return sMethodBody;
}
/**
* Generates all required_once statements for the class header
*
* @param modelElement the class
*
* @return source code for all required_once statements
*
* TODO: fix the comparator code
*/
private String generateRequired(Object modelElement) {
String sRequired = "";
if (!ModelFacade.isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}
TreeSet tsRequired = new TreeSet(
new Comparator() {
public int compare(Object obj1, Object obj2) {
if (obj1 != null) {
if (!ModelFacade.isAClassifier(obj1)) {
throw new ClassCastException(obj1.getClass()
+ " is not comparable as classifier");
}
if (!ModelFacade.isAClassifier(obj2)) {
throw new ClassCastException(obj2.getClass()
+ " is not comparable as classifier");
}
String sFilename1 = NameGenerator.generateFilename(obj1,
iLanguageMajorVersion);
if (sFilename1 != null) {
return sFilename1.compareTo(NameGenerator
.generateFilename(obj2, iLanguageMajorVersion));
} else {
return (NameGenerator.generateFilename(obj2,
iLanguageMajorVersion) != null) ? -1 : 0;
}
} else {
if (obj2 != null) {
return -1;
} else {
return 0;
}
}
}
}
);
/* generalisations */
Collection colGens = ModelFacade.getGeneralizations(modelElement);
if (colGens != null) {
Iterator itGens = colGens.iterator();
while (itGens.hasNext()) {
Object objGen = itGens.next();
tsRequired.add(ModelFacade.getParent(objGen));
}
}
/* association ends */
Collection colAssocEnds = ModelFacade.getAssociationEnds(modelElement);
if (colAssocEnds != null) {
Iterator itAssocEnds = colAssocEnds.iterator();
while (itAssocEnds.hasNext()) {
Object assocEnd = itAssocEnds.next();
Object oppositeEnd = ModelFacade.getOppositeEnd(assocEnd);
if (ModelFacade.isNavigable(oppositeEnd)) {
tsRequired.add(ModelFacade.getType(oppositeEnd));
}
}
}
/* client dependencies */
Collection colClientDeps =
ModelFacade.getClientDependencies(modelElement);
if (colClientDeps != null) {
Iterator itClientDeps = colClientDeps.iterator();
while (itClientDeps.hasNext()) {
Object dep = itClientDeps.next();
Collection colDepSuppliers = ModelFacade.getSuppliers(dep);
Iterator itDepSuppliers = colDepSuppliers.iterator();
while (itDepSuppliers.hasNext()) {
tsRequired.add(itDepSuppliers.next());
}
}
}
Iterator itRequired = tsRequired.iterator();
if (itRequired != null) {
while (itRequired.hasNext()) {
Object objRequired = itRequired.next();
if (!objRequired.equals(modelElement)) {
sRequired += generateRequireOnceStatement(objRequired,
true) + "\n";
}
}
}
return sRequired;
}
/**
* Finds the model element that represents the class constructor
*
* @param modelElement The model element to find constructor for
*
* @return The constructor operation element;
* null otherwise;
*
* TODO: implement the lookup
*/
private final Object findConstructor(Object modelElement) {
if (!ModelFacade.isAClass(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Class required");
}
return null;
}
/**
* @see org.argouml.application.api.NotationProvider2#generateActionState(java.lang.Object)
*/
public String generateActionState(Object actionState) {
return generateState(actionState);
}
}
|
The search page
Other source code files at this package level
Click here to learn more about this project