// we basically want to update the doc and start text of this method void JavaCodeOperation::updateMethodDeclaration() { CodeDocument * doc = getParentDocument(); JavaClassifierCodeDocument * javadoc = dynamic_cast<JavaClassifierCodeDocument*>(doc); UMLOperation * o = getParentOperation(); bool isInterface = javadoc->getParentClassifier()->isInterface(); QString endLine = getNewLineEndingChars(); // now, the starting text. QString strVis = Uml::Visibility::toString(o->visibility()); // no return type for constructors QString fixedReturn = JavaCodeGenerator::fixTypeName(o->getTypeName()); QString returnType = o->isConstructorOperation() ? QString() : (fixedReturn + QLatin1String(" ")); QString methodName = o->name(); QString paramStr; // assemble parameters UMLAttributeList list = getParentOperation()->getParmList(); int nrofParam = list.count(); int paramNum = 0; foreach (UMLAttribute* parm, list) { QString rType = parm->getTypeName(); QString paramName = parm->name(); paramStr += rType + QLatin1Char(' ') + paramName; paramNum++; if (paramNum != nrofParam) paramStr += QLatin1String(", "); }
int RubyCodeOperation::lastEditableLine() { ClassifierCodeDocument * doc = dynamic_cast<ClassifierCodeDocument*>(getParentDocument()); if(doc->parentIsInterface()) return -1; // very last line is NOT editable as its a one-line declaration w/ no body in // an interface. return 0; }
// we basically want to update the doc and start text of this method void DCodeOperation::updateMethodDeclaration() { CodeDocument * doc = getParentDocument(); DClassifierCodeDocument * ddoc = dynamic_cast<DClassifierCodeDocument*>(doc); UMLOperation * o = getParentOperation(); bool isInterface = ddoc->getParentClassifier()->isInterface(); QString endLine = getNewLineEndingChars(); /* * Member function declaration * * (visibility) (static | abstract | override) retType name (param1, ..., paramN) (; | {) * a b c d e f g h */ QString startText; // (a) visibility modifier //FIXME: startText += o->getVisibility().toString() + " "; // (b) static if (o->isStatic()) startText += "static "; // (c) abstract //TODO // (d) override //TODO // (e) return type if (!o->isConstructorOperation()) { //FIXME: startText += DCodeGenerator::fixTypeName(o->getTypeName()) + " "; } // (f) name startText += o->name(); // (g) params startText += '('; // assemble parameters QString paramStr = QString(""); UMLAttributeList list = getParentOperation()->getParmList(); int paramNum = list.count(); foreach (UMLAttribute* parm, list ) { QString rType = parm->getTypeName(); QString paramName = parm->name(); paramStr += rType + ' ' + paramName; paramNum--; if (paramNum > 0) paramStr += ", "; }
// we basically want to update the doc and start text of this method void RubyCodeOperation::updateMethodDeclaration() { CodeDocument * doc = getParentDocument(); RubyClassifierCodeDocument * rubydoc = dynamic_cast<RubyClassifierCodeDocument*>(doc); UMLClassifier *c = rubydoc->getParentClassifier(); UMLOperation * o = getParentOperation(); bool isInterface = rubydoc->getParentClassifier()->isInterface(); QString endLine = getNewLineEndingChars(); // now, the starting text. //:UNUSED: QString strVis = o->visibility().toString(); // no return type for constructors QString fixedReturn = RubyCodeGenerator::cppToRubyType(o->getTypeName()); QString returnType = o->isConstructorOperation() ? QString("") : (fixedReturn + QString(" ")); QString methodName = o->name(); QString RubyClassName = rubydoc->getRubyClassName(c->name()); // Skip destructors, and operator methods which // can't be defined in ruby if ( methodName.startsWith('~') || QRegExp("operator\\s*(=|--|\\+\\+|!=)$").exactMatch(methodName) ) { getComment()->setText(""); return; } if (RubyClassName == methodName) { methodName = "initialize"; } methodName.remove(QRegExp("operator\\s*")); methodName = methodName.mid(0, 1).toLower() + methodName.mid(1); QString paramStr = QString(""); QStringList commentedParams; // assemble parameters UMLAttributeList list = getParentOperation()->getParmList(); int nrofParam = list.count(); int paramNum = 0; foreach (UMLAttribute* parm, list) { QString paramName = RubyCodeGenerator::cppToRubyName(parm->name()); paramStr += paramName; if (! parm->getInitialValue().isEmpty()) { paramStr += QString(" = ") + RubyCodeGenerator::cppToRubyType(parm->getInitialValue()); } paramNum++; if (paramNum != nrofParam ) paramStr += ", "; }
/** * update the start and end text for this hierarchicalcodeblock. */ void CPPHeaderClassDeclarationBlock::updateContent () { CPPHeaderCodeDocument *parentDoc = dynamic_cast<CPPHeaderCodeDocument*>(getParentDocument()); UMLClassifier *c = parentDoc->getParentClassifier(); QString endLine = UMLApp::app()->commonPolicy()->getNewLineEndingChars(); bool isInterface = parentDoc->parentIsInterface(); // a little shortcut QString CPPHeaderClassName = CodeGenerator::cleanName(c->name()); bool forceDoc = UMLApp::app()->commonPolicy()->getCodeVerboseDocumentComments(); // COMMENT //check if class is abstract.. it should have abstract methods if(!isInterface && c->isAbstract() && !c->hasAbstractOps()) { getComment()->setText(QLatin1String("******************************* Abstract Class ****************************") + endLine + CPPHeaderClassName + QLatin1String(" does not have any pure virtual methods, but its author") + endLine + QLatin1String(" defined it as an abstract class, so you should not use it directly.") + endLine + QLatin1String(" Inherit from it instead and create only objects from the derived classes") + endLine + QLatin1String("*****************************************************************************")); } else { if(isInterface) getComment()->setText(QLatin1String("Interface ") + CPPHeaderClassName + endLine + c->doc()); else getComment()->setText(QLatin1String("Class ") + CPPHeaderClassName + endLine + c->doc()); } if(forceDoc || !c->doc().isEmpty()) getComment()->setWriteOutText(true); else getComment()->setWriteOutText(false); // Now set START/ENDING Text QString startText; /* */ /* if(parentDoc->parentIsInterface()) startText.append(QLatin1String("interface ")); else */ startText.append(QLatin1String("class ")); startText.append(CPPHeaderClassName); // write inheritances out UMLClassifierList superclasses = c->findSuperClassConcepts(); int nrof_superclasses = superclasses.count(); // write out inheritance int i = 0; if(nrof_superclasses >0) startText.append(QLatin1String(" : ")); foreach (UMLClassifier* concept, superclasses) { startText.append(Uml::Visibility::toString(concept->visibility()) + QLatin1Char(' ') + CodeGenerator::cleanName(concept->name())); if(i != (nrof_superclasses-1)) startText.append(QLatin1String(", ")); i++; }
// remove methods from parent document Q_FOREACH(CodeAccessorMethod *m, m_methodVector) { getParentDocument()->removeTextBlock(m); m->forceRelease(); }
// we basically want to update the doc and start text of this method void RubyCodeOperation::updateMethodDeclaration() { CodeDocument * doc = getParentDocument(); RubyClassifierCodeDocument * rubydoc = dynamic_cast<RubyClassifierCodeDocument*>(doc); UMLClassifier *c = rubydoc->getParentClassifier(); UMLOperation * o = getParentOperation(); bool isInterface = rubydoc->getParentClassifier()->isInterface(); QString endLine = getNewLineEndingChars(); // now, the starting text. QString strVis = rubydoc->scopeToRubyDecl(o->getVisibility()); // no return type for constructors QString fixedReturn = RubyCodeGenerator::cppToRubyType(o->getTypeName()); QString returnType = o->isConstructorOperation() ? QString("") : (fixedReturn + QString(" ")); QString methodName = o->getName(); QString RubyClassName = rubydoc->getRubyClassName(c->getName()); // Skip destructors, and operator methods which // can't be defined in ruby if ( methodName.startsWith("~") || QRegExp("operator\\s*(=|--|\\+\\+|!=)$").exactMatch(methodName) ) { getComment()->setText(""); return; } if (RubyClassName == methodName) { methodName = "initialize"; } methodName.replace(QRegExp("operator\\s*"), ""); methodName = methodName.mid(0, 1).lower() + methodName.mid(1); QString paramStr = QString(""); QStringList commentedParams; // assemble parameters UMLAttributeList list = getParentOperation()->getParmList(); int nrofParam = list.count(); int paramNum = 0; for(UMLAttribute* parm = list.first(); parm; parm = list.next()) { QString paramName = RubyCodeGenerator::cppToRubyName(parm->getName()); paramStr += paramName; if (! parm->getInitialValue().isEmpty()) { paramStr += QString(" = ") + RubyCodeGenerator::cppToRubyType(parm->getInitialValue()); } paramNum++; if (paramNum != nrofParam ) paramStr += ", "; } QString startText; if (isInterface) { // Assume 'isInterface' means a module in Ruby, so // generate module methods startText = "def "+ RubyClassName + '.' + methodName + '(' + paramStr +')'; } else { startText = "def "+ methodName + '(' + paramStr +')'; } startText += ""; setEndMethodText("end"); setStartMethodText(startText); // Lastly, for text content generation, we fix the comment on the // operation, IF the codeop is autogenerated & currently empty QString comment = o->getDoc(); if (comment.isEmpty()) { if (getContentType() == CodeBlock::AutoGenerated) { UMLAttributeList parameters = o->getParmList(); for(UMLAttributeListIt iterator(parameters); iterator.current(); ++iterator) { comment += endLine + "* _" + iterator.current()->getName() + "_ "; comment += (' ' + iterator.current()->getDoc().replace( QRegExp("[\\n\\r]+[\\t ]*"), endLine + " " ) ); } // add a returns statement too if(!returnType.isEmpty() && !QRegExp("^void\\s*$").exactMatch(returnType)) comment += endLine + "* _returns_ " + returnType + ' '; getComment()->setText(comment); } } else { comment.replace(QRegExp("[\\n\\r]+ *"), endLine); comment.replace(QRegExp("[\\n\\r]+\\t*"), endLine); comment.replace(" m_", " "); comment.replace(QRegExp("\\s[npb](?=[A-Z])"), " "); QRegExp re_params("@param (\\w)(\\w*)"); int pos = re_params.search(comment); while (pos != -1) { comment.replace( re_params.cap(0), QString("@param _") + re_params.cap(1).lower() + re_params.cap(2) + '_' ); commentedParams.append(re_params.cap(1).lower() + re_params.cap(2)); pos += re_params.matchedLength() + 3; pos = re_params.search(comment, pos); } UMLAttributeList parameters = o->getParmList(); for (UMLAttributeListIt iterator(parameters); iterator.current(); ++iterator) { // Only write an individual @param entry if one hasn't been found already // in the main doc comment if (commentedParams.contains(RubyCodeGenerator::cppToRubyName(iterator.current()->getName())) == 0) { comment += (endLine + "@param _" + RubyCodeGenerator::cppToRubyName(iterator.current()->getName()) + '_'); if (iterator.current()->getDoc().isEmpty()) { comment += (' ' + RubyCodeGenerator::cppToRubyType(iterator.current()->getTypeName())); } else { comment += (' ' + iterator.current()->getDoc().replace(QRegExp("[\\n\\r]+[\\t ]*"), endLine + " ")); } } } comment.replace("@ref ", ""); comment.replace("@param", "*"); comment.replace("@return", "* _returns_"); // All lines after the first one starting with '*' in the doc comment // must be indented correctly. If they aren't a list // item starting with '*', then indent the text with // two spaces, ' ', to line up with the list item. pos = comment.find(endLine + '*'); if (pos != -1) { pos += endLine.length() + 1; pos = comment.find(endLine, pos); } while (pos > 0) { pos += endLine.length(); if (comment[pos] != '*') { comment.insert(pos, " "); pos += 2; } pos = comment.find(endLine, pos); } QString typeStr = RubyCodeGenerator::cppToRubyType(o->getTypeName()); if ( !typeStr.isEmpty() && !QRegExp("^void\\s*$").exactMatch(typeStr) && comment.contains("_returns_") == 0 ) { comment += endLine + "* _returns_ " + typeStr; } getComment()->setText(comment); } // In Java, for interfaces..we DONT write out non-public // method declarations. And for Ruby modules? if (isInterface) { UMLOperation * o = getParentOperation(); if(o->getVisibility() != Uml::Visibility::Public) setWriteOutText(false); } }
/** * update the start and end text for this ownedhierarchicalcodeblock. */ void JavaClassDeclarationBlock::updateContent ( ) { JavaClassifierCodeDocument *parentDoc = dynamic_cast<JavaClassifierCodeDocument*>(getParentDocument()); UMLClassifier *c = parentDoc->getParentClassifier(); CodeGenerationPolicy *commonPolicy = UMLApp::app()->getCommonPolicy(); QString endLine = commonPolicy->getNewLineEndingChars(); bool isInterface = parentDoc->parentIsInterface(); // a little shortcut QString JavaClassName = parentDoc->getJavaClassName(c->getName()); // COMMENT if(isInterface) getComment()->setText("Interface "+JavaClassName+endLine+c->getDoc()); else getComment()->setText("Class "+JavaClassName+endLine+c->getDoc()); bool forceDoc = UMLApp::app()->getCommonPolicy()->getCodeVerboseDocumentComments(); if(forceDoc || !c->getDoc().isEmpty()) getComment()->setWriteOutText(true); else getComment()->setWriteOutText(false); // Now set START/ENDING Text QString startText = ""; // In Java, we need declare abstract only on classes if (c->getAbstract() && !isInterface) startText.append("abstract "); if (c->getVisibility() != Uml::Visibility::Public) { // We should probably emit a warning in here .. java doesn't like to allow // private/protected classes. The best we can do (I believe) // is to let these declarations default to "package visibility" // which is a level between traditional "private" and "protected" // scopes. To get this visibility level we just print nothing.. } else startText.append("public "); if(parentDoc->parentIsInterface()) startText.append("interface "); else startText.append("class "); startText.append(JavaClassName); // write inheritances out UMLClassifierList superclasses = c->findSuperClassConcepts(UMLClassifier::CLASS); UMLClassifierList superinterfaces = c->findSuperClassConcepts(UMLClassifier::INTERFACE); int nrof_superclasses = superclasses.count(); int nrof_superinterfaces = superinterfaces.count(); // write out inheritance int i = 0; if(nrof_superclasses >0) startText.append(" extends "); for (UMLClassifier * concept= superclasses.first(); concept; concept = superclasses.next()) { startText.append(parentDoc->cleanName(concept->getName())); if(i != (nrof_superclasses-1)) startText.append(", "); i++; } // write out what we 'implement' i = 0; if(nrof_superinterfaces >0) { // In Java interfaces "extend" other interfaces. Classes "implement" interfaces if(isInterface) startText.append(" extends "); else startText.append(" implements "); } for (UMLClassifier * concept= superinterfaces.first(); concept; concept = superinterfaces.next()) { startText.append(parentDoc->cleanName(concept->getName())); if(i != (nrof_superinterfaces-1)) startText.append(", "); i++; } // Set the header and end text for the hier.codeblock setStartText(startText+" {"); // setEndText("}"); // not needed }