/** * @return QString */ QString JavaCodeDocumentation::toString ( ) { QString output = ""; // simple output method if(getWriteOutText()) { bool useDoubleDashOutput = true; // need to figure out output type from java policy CodeGenerationPolicy *p = UMLApp::app()->getCommonPolicy(); if(p->getCommentStyle() == CodeGenerationPolicy::MultiLine) useDoubleDashOutput = false; QString indent = getIndentationString(); QString endLine = getNewLineEndingChars(); QString body = getText(); if(useDoubleDashOutput) { if(!body.isEmpty()) output.append(formatMultiLineText (body, indent +"// ", endLine)); } else { output.append(indent+"/**"+endLine); output.append(formatMultiLineText (body, indent +" * ", endLine)); output.append(indent+" */"+endLine); } } return output; }
void CPPCodeGenerationPolicyPage::apply() { CodeGenerationPolicy *common = UMLApp::app()->getCommonPolicy(); // now do our cpp-specific configs CPPCodeGenerationPolicy * parent = (CPPCodeGenerationPolicy*) m_parentPolicy; // block signals so that we don't generate too many sync signals for child code // documents parent->blockSignals(true); common->setCommentStyle((CodeGenerationPolicy::CommentStyle ) form->m_SelectCommentStyle->currentItem()); common->setAutoGenerateConstructors(form->getGenerateEmptyConstructors()); parent->setAutoGenerateAccessors(form->getGenerateAccessorMethods()); parent->setDestructorsAreVirtual(form->getVirtualDestructors()); parent->setPackageIsNamespace(form->getPackageIsANamespace()); parent->setAccessorsAreInline(form->getAccessorsAreInline()); parent->setOperationsAreInline(form->getOperationsAreInline()); parent->setAccessorsArePublic(form->getAccessorsArePublic()); parent->setStringClassName(form->m_stringClassHCombo->currentText()); parent->setStringClassNameInclude(form->m_stringIncludeFileHistoryCombo->currentText()); parent->setStringIncludeIsGlobal(form->m_globalStringCheckBox->isChecked()); parent->setVectorClassName(form->m_listClassHCombo->currentText()); parent->setVectorClassNameInclude(form->m_listIncludeFileHistoryCombo->currentText()); parent->setVectorIncludeIsGlobal(form->m_globalListCheckBox->isChecked()); parent->blockSignals(false); // now send out modified code content signal common->emitModifiedCodeContentSig(); }
int CPPCodeDocumentation::firstEditableLine() { CodeGenerationPolicy * p = UMLApp::app()->commonPolicy(); if(p->getCommentStyle() == CodeGenerationPolicy::MultiLine) return 1; return 0; }
CPPCodeGenerationPolicyPage::CPPCodeGenerationPolicyPage( QWidget *parent, const char *name, CPPCodeGenerationPolicy * policy ) : CodeGenerationPolicyPage(parent, name, policy) { CodeGenerationPolicy *common = UMLApp::app()->commonPolicy(); QVBoxLayout* vboxLayout = new QVBoxLayout( this ); form = new CPPCodeGenerationForm(this); form->ui_selectCommentStyle->setCurrentIndex((int)(common->getCommentStyle())); form->setPackageIsANamespace(policy->getPackageIsNamespace()); form->setVirtualDestructors(policy->getDestructorsAreVirtual()); form->setGenerateAccessorMethods(policy->getAutoGenerateAccessors()); form->setGenerateEmptyConstructors(common->getAutoGenerateConstructors()); form->setOperationsAreInline(policy->getOperationsAreInline()); form->setAccessorsAreInline(policy->getAccessorsAreInline()); form->setAccessorsArePublic(policy->getAccessorsArePublic()); form->setDocToolTag(policy->getDocToolTag()); form->ui_stringClassHCombo->setCurrentItem(policy->getStringClassName(),true); form->ui_listClassHCombo->setCurrentItem(policy->getVectorClassName(),true); form->ui_stringIncludeFileHistoryCombo->setCurrentItem(policy->getStringClassNameInclude(),true); form->ui_listIncludeFileHistoryCombo->setCurrentItem(policy->getVectorClassNameInclude(),true); form->ui_globalStringCheckBox->setChecked(policy->stringIncludeIsGlobal()); form->ui_globalListCheckBox->setChecked(policy->vectorIncludeIsGlobal()); vboxLayout->addWidget( form ); }
QString DCodeDocumentation::toString() const { QString output; // simple output method if(getWriteOutText()) { bool useDoubleDashOutput = true; // need to figure out output type from d policy CodeGenerationPolicy * p = UMLApp::app()->commonPolicy(); if(p->getCommentStyle() == CodeGenerationPolicy::MultiLine) useDoubleDashOutput = false; QString indent = getIndentationString(); QString endLine = getNewLineEndingChars(); QString body = getText(); if(useDoubleDashOutput) { if(!body.isEmpty()) { output += (formatMultiLineText (body, indent + QLatin1String("// "), endLine)); } } else { output += indent + QLatin1String("/**") + endLine; output += formatMultiLineText (body, indent + QLatin1String(" * "), endLine); output += indent + QLatin1String(" */") + endLine; } } return output; }
int JavaCodeDocumentation::lastEditableLine() { CodeGenerationPolicy *p = UMLApp::app()->getCommonPolicy(); if(p->getCommentStyle() == CodeGenerationPolicy::MultiLine) { return -1; // very last line is NOT editable } return 0; }
QString JavaCodeDocumentation::getNewEditorLine ( int amount ) { CodeGenerationPolicy *p = UMLApp::app()->getCommonPolicy(); if(p->getCommentStyle() == CodeGenerationPolicy::MultiLine) return getIndentationString(amount) + " * "; else return getIndentationString(amount) + "// "; }
void JavaCodeGenerationPolicyPage::apply() { CodeGenerationPolicy *commonPolicy = UMLApp::app()->commonPolicy(); JavaCodeGenerationPolicy * parent = (JavaCodeGenerationPolicy*) m_parentPolicy; // block signals so we don't cause too many update content calls to code documents commonPolicy->blockSignals(true); commonPolicy->setCommentStyle((CodeGenerationPolicy::CommentStyle) form->m_SelectCommentStyle->currentIndex()); commonPolicy->setAttributeAccessorScope(Uml::Visibility::fromInt(form->m_accessorScopeCB->currentIndex())); commonPolicy->setAssociationFieldScope(Uml::Visibility::fromInt(form->m_assocFieldScopeCB->currentIndex())); commonPolicy->setAutoGenerateConstructors(form->m_generateConstructors->isChecked()); parent->setAutoGenerateAttribAccessors(form->m_generateAttribAccessors->isChecked()); parent->setAutoGenerateAssocAccessors(form->m_generateAssocAccessors->isChecked()); /** * @todo unclean - CreateANTBuildFile attribute should be in java policy CodeGenerator *codegen = UMLApp::app()->getGenerator(); JavaCodeGenerator *javacodegen = dynamic_cast<JavaCodeGenerator*>(codegen); if (javacodegen) javacodegen->setCreateANTBuildFile(form->m_makeANTDocumentCheckBox->isChecked()); */ commonPolicy->blockSignals(false); // now send out modified code content signal commonPolicy->emitModifiedCodeContentSig(); }
/** * This function is called when leaving this wizard page. * Saves the made settings and checks some values. * @return the success state */ bool CodeGenOptionsPage::save() { // first save the settings to the selected generator policy apply(); // before going on to the generation page, check that the output directory // exists and is writable // get the policy for the current code generator CodeGenerationPolicy *policy = UMLApp::app()->commonPolicy(); // get the output directory path QFileInfo info(policy->getOutputDirectory().absolutePath()); if (info.exists()) { // directory exists... make sure we can write to it if (!info.isWritable()) { KMessageBox::sorry(this, i18n("The output folder exists, but it is not writable.\nPlease set the appropriate permissions or choose another folder."), i18n("Error Writing to Output Folder")); return false; } // it exits and we can write... make sure it is a directory if (!info.isDir()) { KMessageBox::sorry(this, i18n("%1 does not seem to be a folder. Please choose a valid folder.", info.filePath()), i18n("Please Choose Valid Folder")); return false; } } else { if (KMessageBox::questionYesNo(this, i18n("The folder %1 does not exist. Do you want to create it now?", info.filePath()), i18n("Output Folder Does Not Exist"), KGuiItem(i18n("Create Folder")), KGuiItem(i18n("Do Not Create"))) == KMessageBox::Yes) { QDir dir; if (!dir.mkdir(info.filePath())) { KMessageBox::sorry(this, i18n("The folder could not be created.\nPlease make sure you have write access to its parent folder or select another, valid, folder."), i18n("Error Creating Folder")); return false; } // else, directory created } else { // do not create output directory KMessageBox::information(this, i18n("Please select a valid folder."), i18n("Output Folder Does Not Exist")); return false; } } return true; }
/** UnFormat a long text string. Typically, this means removing * the indentaion (linePrefix) and/or newline chars from each line. */ QString CPPCodeDocumentation::unformatText(const QString & text, const QString & indent) { QString mytext = TextBlock::unformatText(text, indent); CodeGenerationPolicy * p = UMLApp::app()->commonPolicy(); // remove leading or trailing comment stuff mytext.remove(QRegExp(QLatin1Char('^') + indent)); if(p->getCommentStyle() == CodeGenerationPolicy::MultiLine) { mytext.remove(QRegExp(QLatin1String("^\\/\\*\\*\\s*\n?"))); mytext.remove(QRegExp(QLatin1String("\\s*\\*\\/\\s*\n?$"))); mytext.remove(QRegExp(QLatin1String("^\\s*\\*\\s*"))); } else mytext.remove(QRegExp(QLatin1String("^\\/\\/\\s*"))); return mytext; }
JavaCodeGenerationPolicyPage::JavaCodeGenerationPolicyPage(QWidget *parent, const char *name, JavaCodeGenerationPolicy * policy) : CodeGenerationPolicyPage(parent, name, policy) { CodeGenerationPolicy *commonPolicy = UMLApp::app()->commonPolicy(); form = new JavaCodeGenerationFormBase(this); form->m_SelectCommentStyle->setCurrentIndex((int)(commonPolicy->getCommentStyle())); form->m_generateConstructors->setChecked(commonPolicy->getAutoGenerateConstructors()); form->m_generateAttribAccessors->setChecked(policy->getAutoGenerateAttribAccessors()); form->m_generateAssocAccessors->setChecked(policy->getAutoGenerateAssocAccessors()); form->m_accessorScopeCB->setCurrentIndex(commonPolicy->getAttributeAccessorScope()); form->m_assocFieldScopeCB->setCurrentIndex(commonPolicy->getAssociationFieldScope()); /** * @todo unclean - CreateANTBuildFile attribute should be in java policy CodeGenerator *codegen = UMLApp::app()->getGenerator(); JavaCodeGenerator *javacodegen = dynamic_cast<JavaCodeGenerator*>(codegen); if (javacodegen) form->m_makeANTDocumentCheckBox->setChecked(javacodegen->getCreateANTBuildFile()); */ }
void RubyCodeClassFieldDeclarationBlock::updateContent( ) { CodeClassField * cf = getParentClassField(); ClassifierCodeDocument * doc = cf->getParentDocument(); RubyCodeClassField * rcf = dynamic_cast<RubyCodeClassField*>(cf); RubyClassifierCodeDocument* rdoc = dynamic_cast<RubyClassifierCodeDocument*>(doc); CodeGenerationPolicy * p = UMLApp::app()->getCommonPolicy(); CodeGenerationPolicy::ScopePolicy scopePolicy = p->getAssociationFieldScope(); // Set the comment QString notes = getParentObject()->getDoc(); getComment()->setText(notes); // Set the body QString staticValue = getParentObject()->getStatic() ? "static " : ""; QString scopeStr = rdoc->scopeToRubyDecl(getParentObject()->getVisibility()); // IF this is from an association, then scope taken as appropriate to policy if(!rcf->parentIsAttribute()) { switch (scopePolicy) { case CodeGenerationPolicy::Public: case CodeGenerationPolicy::Private: case CodeGenerationPolicy::Protected: scopeStr = rdoc->scopeToRubyDecl((Uml::Visibility::Value) scopePolicy); break; default: case CodeGenerationPolicy::FromParent: // do nothing here... will leave as from parent object break; } } QString typeName = rcf->getTypeName(); QString fieldName = rcf->getFieldName(); QString initialV = rcf->getInitialValue(); if (!cf->parentIsAttribute() && !cf->fieldIsSingleValue()) typeName = "Array"; QString body = staticValue+scopeStr+' '+typeName+' '+fieldName; if (!initialV.isEmpty()) body.append(" = " + initialV); else if (!cf->parentIsAttribute()) { UMLRole * role = dynamic_cast<UMLRole*>(cf->getParentObject()); if (role->getObject()->getBaseType() == Uml::ot_Interface) { // do nothing.. can't instanciate an interface } else { // FIX?: IF a constructor method exists in the classifiercodedoc // of the parent Object, then we can use that instead (if its empty). if(cf->fieldIsSingleValue()) { if(!typeName.isEmpty()) body.append(" = " + typeName + ".new()"); } else body.append(" = []"); } } setText(body); }
/** * 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 }
void DCodeAccessorMethod::updateMethodDeclaration() { DCodeClassField * dfield = dynamic_cast<DCodeClassField*>(getParentClassField()); // Check for dynamic casting failure! if (dfield == 0) { uError() << "dfield: invalid dynamic cast"; return; } CodeGenerationPolicy *commonpolicy = UMLApp::app()->commonPolicy(); // gather defs Uml::Visibility::Enum scopePolicy = commonpolicy->getAttributeAccessorScope(); QString strVis = Uml::Visibility::toString(dfield->getVisibility()); QString fieldName = dfield->getFieldName(); QString fieldType = dfield->getTypeName(); QString objectType = dfield->getListObjectType(); if(objectType.isEmpty()) objectType = fieldName; QString endLine = UMLApp::app()->commonPolicy()->getNewLineEndingChars(); // set scope of this accessor appropriately..if its an attribute, // we need to be more sophisticated if (dfield->parentIsAttribute()) { switch (scopePolicy) { case Uml::Visibility::Public: case Uml::Visibility::Private: case Uml::Visibility::Protected: strVis = Uml::Visibility::toString(scopePolicy); break; default: case Uml::Visibility::FromParent: // do nothing..already have taken parent value break; } } // some variables we will need to populate QString headerText; QString methodReturnType; QString methodName; QString methodParams; switch(getType()) { case CodeAccessorMethod::ADD: methodName = QLatin1String("add") + Codegen_Utils::capitalizeFirstLetter(fieldType); methodReturnType = QLatin1String("void"); methodParams = objectType + QLatin1String(" value "); headerText = QLatin1String("Add an object of type ") + objectType + QLatin1String(" to the List ") + fieldName + endLine + getParentObject()->doc() + endLine + QLatin1String("@return void"); break; case CodeAccessorMethod::GET: methodName = QLatin1String("get") + Codegen_Utils::capitalizeFirstLetter(fieldName); methodReturnType = fieldType; headerText = QLatin1String("Get the value of ") + fieldName + endLine + getParentObject()->doc() + endLine + QLatin1String("@return the value of ") + fieldName; break; case CodeAccessorMethod::LIST: methodName = QLatin1String("get") + Codegen_Utils::capitalizeFirstLetter(fieldType) + QLatin1String("List"); methodReturnType = QLatin1String("List"); headerText = QLatin1String("Get the list of ") + fieldName + endLine + getParentObject()->doc() + endLine + QLatin1String("@return List of ") + fieldName; break; case CodeAccessorMethod::REMOVE: methodName = QLatin1String("remove") + Codegen_Utils::capitalizeFirstLetter(fieldType); methodReturnType = QLatin1String("void"); methodParams = objectType + QLatin1String(" value "); headerText = QLatin1String("Remove an object of type ") + objectType + QLatin1String(" from the List ") + fieldName + endLine + getParentObject()->doc(); break; case CodeAccessorMethod::SET: methodName = QLatin1String("set") + Codegen_Utils::capitalizeFirstLetter(fieldName); methodReturnType = QLatin1String("void"); methodParams = fieldType + QLatin1String(" value "); headerText = QLatin1String("Set the value of ") + fieldName + endLine + getParentObject()->doc() + endLine; break; default: // do nothing..no idea what this is uWarning()<<"Warning: cant generate DCodeAccessorMethod for type: "<<getType(); break; } // set header once. if(getComment()->getText().isEmpty()) getComment()->setText(headerText); // set start/end method text setStartMethodText(strVis + QLatin1Char(' ') + methodReturnType + QLatin1Char(' ') + methodName + QLatin1String(" (") + methodParams + QLatin1String(") {")); setEndMethodText(QLatin1String("}")); }
/** * Get how much a single "level" of indentation will actually indent. * @return the unit of indentation (for one level) */ QString TextBlock::getIndentation() { CodeGenerationPolicy* policy = UMLApp::app()->commonPolicy(); return policy->getIndentation(); }
/** * Get the new line chars which ends the line. * @return the ending chars for new line */ QString TextBlock::getNewLineEndingChars() { CodeGenerationPolicy* policy = UMLApp::app()->commonPolicy(); return policy->getNewLineEndingChars(); }
/** * Check if a file named "name" with extension "ext" already exists. * @param concept the package * @param name the name of the file * @param ext the extension of the file * @return the valid filename or null */ QString SimpleCodeGenerator::overwritableName(UMLPackage* concept, const QString &name, const QString &ext) { CodeGenerationPolicy *commonPolicy = UMLApp::app()->commonPolicy(); QDir outputDir = commonPolicy->getOutputDirectory(); QString filename = name + ext; if(!outputDir.exists(filename)) { m_fileMap.insert(concept,filename); return filename; //if not, "name" is OK and we have not much to to } int suffix; QPointer<OverwriteDialogue> overwriteDialogue = new OverwriteDialogue(filename, outputDir.absolutePath(), m_applyToAllRemaining, kapp->activeWindow()); switch(commonPolicy->getOverwritePolicy()) { //if it exists, check the OverwritePolicy we should use case CodeGenerationPolicy::Ok: //ok to overwrite file break; case CodeGenerationPolicy::Ask: //ask if we can overwrite switch(overwriteDialogue->exec()) { case KDialog::Yes: //overwrite file if ( overwriteDialogue->applyToAllRemaining() ) { commonPolicy->setOverwritePolicy(CodeGenerationPolicy::Ok); } else { m_applyToAllRemaining = false; } break; case KDialog::No: //generate similar name suffix = 1; while (1) { filename = name + "__" + QString::number(suffix) + ext; if (!outputDir.exists(filename)) break; suffix++; } if ( overwriteDialogue->applyToAllRemaining() ) { commonPolicy->setOverwritePolicy(CodeGenerationPolicy::Never); } else { m_applyToAllRemaining = false; } break; case KDialog::Cancel: //don't output anything if ( overwriteDialogue->applyToAllRemaining() ) { commonPolicy->setOverwritePolicy(CodeGenerationPolicy::Cancel); } else { m_applyToAllRemaining = false; } delete overwriteDialogue; return QString(); break; } break; case CodeGenerationPolicy::Never: //generate similar name suffix = 1; while (1) { filename = name + "__" + QString::number(suffix) + ext; if (!outputDir.exists(filename)) break; suffix++; } break; case CodeGenerationPolicy::Cancel: //don't output anything delete overwriteDialogue; return QString(); break; } m_fileMap.insert(concept, filename); delete overwriteDialogue; return filename; }
// This method will cause the class to rebuild its text representation. // based on the parent classifier object. // For any situation in which this is called, we are either building the code // document up, or replacing/regenerating the existing auto-generated parts. As // such, we will want to insert everything we resonablely will want // during creation. We can set various parts of the document (esp. the // comments) to appear or not, as needed. void CPPHeaderCodeDocument::updateContent( ) { // Gather info on the various fields and parent objects of this class... UMLClassifier * c = getParentClassifier(); CodeGenPolicyExt *pe = UMLApp::app()->getPolicyExt(); CPPCodeGenerationPolicy * policy = dynamic_cast<CPPCodeGenerationPolicy*>(pe); // first, set the global flag on whether or not to show classfield info CodeClassFieldList * cfList = getCodeClassFieldList(); for(CodeClassField * field = cfList->first(); field; field = cfList->next()) field->setWriteOutMethods(policy->getAutoGenerateAccessors()); // attribute-based ClassFields // we do it this way to have the static fields sorted out from regular ones CodeClassFieldList staticPublicAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true, Uml::Visibility::Public ); CodeClassFieldList publicAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, false, Uml::Visibility::Public ); CodeClassFieldList staticProtectedAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true, Uml::Visibility::Protected ); CodeClassFieldList protectedAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, false, Uml::Visibility::Protected ); CodeClassFieldList staticPrivateAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true, Uml::Visibility::Private ); CodeClassFieldList privateAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, false, Uml::Visibility::Private); // association-based ClassFields // don't care if they are static or not..all are lumped together CodeClassFieldList publicPlainAssocClassFields = getSpecificClassFields ( CodeClassField::PlainAssociation , Uml::Visibility::Public); CodeClassFieldList publicAggregationClassFields = getSpecificClassFields ( CodeClassField::Aggregation, Uml::Visibility::Public); CodeClassFieldList publicCompositionClassFields = getSpecificClassFields ( CodeClassField::Composition, Uml::Visibility::Public ); CodeClassFieldList protPlainAssocClassFields = getSpecificClassFields ( CodeClassField::PlainAssociation , Uml::Visibility::Protected); CodeClassFieldList protAggregationClassFields = getSpecificClassFields ( CodeClassField::Aggregation, Uml::Visibility::Protected); CodeClassFieldList protCompositionClassFields = getSpecificClassFields ( CodeClassField::Composition, Uml::Visibility::Protected); CodeClassFieldList privPlainAssocClassFields = getSpecificClassFields ( CodeClassField::PlainAssociation , Uml::Visibility::Private); CodeClassFieldList privAggregationClassFields = getSpecificClassFields ( CodeClassField::Aggregation, Uml::Visibility::Private); CodeClassFieldList privCompositionClassFields = getSpecificClassFields ( CodeClassField::Composition, Uml::Visibility::Private); bool hasOperationMethods = c->getOpList().last() ? true : false; bool hasNamespace = false; bool isEnumeration = false; bool isInterface = parentIsInterface(); bool hasclassFields = hasClassFields(); bool forcedoc = UMLApp::app()->getCommonPolicy()->getCodeVerboseDocumentComments(); QString endLine = UMLApp::app()->getCommonPolicy()->getNewLineEndingChars(); UMLClassifierList superclasses = c->findSuperClassConcepts(); // START GENERATING CODE/TEXT BLOCKS and COMMENTS FOR THE DOCUMENT // // Write the hash define stuff to prevent multiple parsing/inclusion of header QString cppClassName = CodeGenerator::cleanName(c->getName()); QString hashDefine = CodeGenerator::cleanName(c->getName().upper().simplifyWhiteSpace()); QString defText = "#ifndef "+hashDefine + "_H"+ endLine + "#define "+ hashDefine + "_H"; addOrUpdateTaggedCodeBlockWithComments("hashDefBlock", defText, "", 0, false); // INCLUDE CODEBLOCK // // Q: Why all utils? Isnt just List and Vector the only classes we are using? // A: doesn't matter at all; its more readable to just include '*' and cpp compilers // don't slow down or anything. (TZ) QString includeStatement = ""; bool stringGlobal = policy->stringIncludeIsGlobal(); QString sStartBrak = stringGlobal ? "<" : "\""; QString sEndBrak = stringGlobal ? ">" : "\""; includeStatement.append("#include "+sStartBrak+policy->getStringClassNameInclude()+sEndBrak+endLine); if ( hasObjectVectorClassFields() ) { bool vecGlobal = policy->vectorIncludeIsGlobal(); QString vStartBrak = vecGlobal ? "<" : "\""; QString vEndBrak = vecGlobal ? ">" : "\""; QString value ="#include "+vStartBrak+policy->getVectorClassNameInclude()+vEndBrak; includeStatement.append(value+endLine); } //only include classes in a different package from this class UMLPackageList includes; QMap<UMLPackage *,QString> packageMap; // so we don't repeat packages CodeGenerator::findObjectsRelated(c,includes); for(UMLPackage *con = includes.first(); con ; con = includes.next()) if (con->getBaseType() != Uml::ot_Datatype && !packageMap.contains(con)) { packageMap.insert(con,con->getPackage()); if(con != getParentClassifier()) includeStatement.append("#include \""+CodeGenerator::cleanName(con->getName().lower())+".h\""+endLine); } // now, add/update the includes codeblock CodeBlockWithComments * inclBlock = addOrUpdateTaggedCodeBlockWithComments("includes", includeStatement, QString::null, 0, false); if(includeStatement.isEmpty() && inclBlock->getContentType() == CodeBlock::AutoGenerated) inclBlock->setWriteOutText(false); else inclBlock->setWriteOutText(true); // Using QString usingStatement; for(UMLClassifier *classifier = superclasses.first(); classifier ; classifier = superclasses.next()) { if(classifier->getPackage()!=c->getPackage() && !classifier->getPackage().isEmpty()) { usingStatement.append("using "+CodeGenerator::cleanName(c->getPackage())+"::"+cleanName(c->getName())+';'+endLine); } } CodeBlockWithComments * usingBlock = addOrUpdateTaggedCodeBlockWithComments("using", usingStatement, "", 0, false); if(usingStatement.isEmpty() && usingBlock->getContentType() == CodeBlock::AutoGenerated) usingBlock->setWriteOutText(false); else usingBlock->setWriteOutText(true); // namespace // This needs special treatment. We cant use "nowriteouttext" for this, as // that will prevent the class declaration from being written. Instead, we // check if "hasNamspace" is true or not, and then indent the remaining code // appropriately as well as set the start/end text of this namespace block. if (c->getUMLPackage() && policy->getPackageIsNamespace()) hasNamespace = true; else hasNamespace = false; // set start/end text of namespace block namespaceBlock = getHierarchicalCodeBlock("namespace", "Namespace", 0); if(hasNamespace) { UMLPackageList pkgList = c->getPackages(); QString pkgs; UMLPackage *pkg; for (pkg = pkgList.first(); pkg != NULL; pkg = pkgList.next()) { pkgs += "namespace " + CodeGenerator::cleanName(pkg->getName()) + " { "; } namespaceBlock->setStartText(pkgs); QString closingBraces; for (pkg = pkgList.first(); pkg != NULL; pkg = pkgList.next()) { closingBraces += "} "; } namespaceBlock->setEndText(closingBraces); namespaceBlock->getComment()->setWriteOutText(true); } else { namespaceBlock->setStartText(""); namespaceBlock->setEndText(""); namespaceBlock->getComment()->setWriteOutText(false); } // Enum types for include if (!isInterface) { QString enumStatement; QString indent = UMLApp::app()->getCommonPolicy()->getIndentation(); UMLEnum* e = dynamic_cast<UMLEnum*>(c); if (e) { enumStatement.append(indent + "enum " + cppClassName + " {" + endLine); // populate UMLClassifierListItemList ell = e->getFilteredList(Uml::ot_EnumLiteral); for (UMLClassifierListItem *el=ell.first(); el ; ) { enumStatement.append(indent+indent); enumStatement.append(CodeGenerator::cleanName(el->getName())); if ((el=ell.next()) != 0) enumStatement.append(", "+endLine); else break; enumStatement.append(endLine); } enumStatement.append(indent+"};"); isEnumeration = true; } namespaceBlock->addOrUpdateTaggedCodeBlockWithComments("enums", enumStatement, "", 0, false); } // CLASS DECLARATION BLOCK // // add the class declaration block to the namespace block. CPPHeaderClassDeclarationBlock * myClassDeclCodeBlock = getClassDecl(); namespaceBlock->addTextBlock(myClassDeclCodeBlock); // note: wont add if already present // Is this really true?? hmm.. if(isEnumeration) myClassDeclCodeBlock->setWriteOutText(false); // not written out IF its an enumeration class else myClassDeclCodeBlock->setWriteOutText(true); // // Main Sub-Blocks // // declare public, protected and private methods, attributes (fields). // set the start text ONLY if this is the first time we created the objects. bool createdPublicBlock = publicBlock == 0 ? true : false; publicBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock("publicBlock","Public stuff",0); if (createdPublicBlock) publicBlock->setStartText("public:"); bool createdProtBlock = protectedBlock == 0 ? true : false; protectedBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock("protectedBlock","Protected stuff",0); if(createdProtBlock) protectedBlock->setStartText("protected:"); bool createdPrivBlock = privateBlock == 0 ? true : false; privateBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock("privateBlock","Private stuff",0); if(createdPrivBlock) privateBlock->setStartText("private:"); // // * CLASS FIELD declaration section // // setup/get/create the field declaration code block // // public fields: Update the comment: we only set comment to appear under the following conditions HierarchicalCodeBlock * publicFieldDeclBlock = publicBlock->getHierarchicalCodeBlock("publicFieldsDecl", "Fields", 1); CodeComment * pubFcomment = publicFieldDeclBlock->getComment(); if (!forcedoc && !hasclassFields ) pubFcomment->setWriteOutText(false); else pubFcomment->setWriteOutText(true); // protected fields: Update the comment: we only set comment to appear under the following conditions HierarchicalCodeBlock * protectedFieldDeclBlock = protectedBlock->getHierarchicalCodeBlock("protectedFieldsDecl", "Fields", 1); CodeComment * protFcomment = protectedFieldDeclBlock->getComment(); if (!forcedoc && !hasclassFields ) protFcomment->setWriteOutText(false); else protFcomment->setWriteOutText(true); // private fields: Update the comment: we only set comment to appear under the following conditions HierarchicalCodeBlock * privateFieldDeclBlock = privateBlock->getHierarchicalCodeBlock("privateFieldsDecl", "Fields", 1); CodeComment * privFcomment = privateFieldDeclBlock->getComment(); if (!forcedoc && !hasclassFields ) privFcomment->setWriteOutText(false); else privFcomment->setWriteOutText(true); // now actually declare the fields within the appropriate HCodeBlock // // public declareClassFields(staticPublicAttribClassFields, publicFieldDeclBlock); declareClassFields(publicAttribClassFields, publicFieldDeclBlock); declareClassFields(publicPlainAssocClassFields, publicFieldDeclBlock); declareClassFields(publicAggregationClassFields, publicFieldDeclBlock); declareClassFields(publicCompositionClassFields, publicFieldDeclBlock); // protected declareClassFields(staticProtectedAttribClassFields, protectedFieldDeclBlock); declareClassFields(protectedAttribClassFields, protectedFieldDeclBlock); declareClassFields(protPlainAssocClassFields, protectedFieldDeclBlock); declareClassFields(protAggregationClassFields, protectedFieldDeclBlock); declareClassFields(protCompositionClassFields, protectedFieldDeclBlock); // private declareClassFields(staticPrivateAttribClassFields, privateFieldDeclBlock); declareClassFields(privateAttribClassFields, privateFieldDeclBlock); declareClassFields(privPlainAssocClassFields, privateFieldDeclBlock); declareClassFields(privAggregationClassFields, privateFieldDeclBlock); declareClassFields(privCompositionClassFields, privateFieldDeclBlock); // // METHODS section // // get/create the method codeblock // public methods HierarchicalCodeBlock * pubMethodsBlock = publicBlock->getHierarchicalCodeBlock("pubMethodsBlock", "", 1); CodeComment * pubMethodsComment = pubMethodsBlock->getComment(); // set conditions for showing this comment if (!forcedoc && !hasclassFields && !hasOperationMethods) pubMethodsComment->setWriteOutText(false); else pubMethodsComment->setWriteOutText(true); // protected methods HierarchicalCodeBlock * protMethodsBlock = protectedBlock->getHierarchicalCodeBlock("protMethodsBlock", "", 1); CodeComment * protMethodsComment = protMethodsBlock->getComment(); // set conditions for showing this comment if (!forcedoc && !hasclassFields && !hasOperationMethods) protMethodsComment->setWriteOutText(false); else protMethodsComment->setWriteOutText(true); // private methods HierarchicalCodeBlock * privMethodsBlock = privateBlock->getHierarchicalCodeBlock("privMethodsBlock", "", 1); CodeComment * privMethodsComment = privMethodsBlock->getComment(); // set conditions for showing this comment if (!forcedoc && !hasclassFields && !hasOperationMethods) privMethodsComment->setWriteOutText(false); else privMethodsComment->setWriteOutText(true); // METHODS sub-section : constructor methods // CodeGenerationPolicy *pol = UMLApp::app()->getCommonPolicy(); // setup/get/create the constructor codeblocks // public pubConstructorBlock = pubMethodsBlock->getHierarchicalCodeBlock("constructionMethods", "Constructors", 1); // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * pubConstComment = pubConstructorBlock->getComment(); if (!forcedoc && (isInterface || !pol->getAutoGenerateConstructors())) pubConstComment->setWriteOutText(false); else pubConstComment->setWriteOutText(true); // protected protConstructorBlock = protMethodsBlock->getHierarchicalCodeBlock("constructionMethods", "Constructors", 1); // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * protConstComment = protConstructorBlock->getComment(); if (!forcedoc && (isInterface || !pol->getAutoGenerateConstructors())) protConstComment->setWriteOutText(false); else protConstComment->setWriteOutText(true); // private privConstructorBlock = privMethodsBlock->getHierarchicalCodeBlock("constructionMethods", "Constructors", 1); // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * privConstComment = privConstructorBlock->getComment(); if (!forcedoc && (isInterface || !pol->getAutoGenerateConstructors())) privConstComment->setWriteOutText(false); else privConstComment->setWriteOutText(true); // add/get the empty constructor. I guess since there is no // meta-data to state what the scope of this method is, we will make it // "public" as a default. This might present problems if the user wants // to move the block into the "private" or "protected" blocks. QString emptyConstStatement = cppClassName + " ( ) { }"; // search for this first in the entire document. IF not present, put // it in the public constructor method block TextBlock * emptyConstTb = findTextBlockByTag("emptyconstructor", true); CodeBlockWithComments * emptyConstBlock = dynamic_cast<CodeBlockWithComments*>(emptyConstTb); if(!emptyConstBlock) emptyConstBlock = pubConstructorBlock->addOrUpdateTaggedCodeBlockWithComments("emptyconstructor", emptyConstStatement, "Empty Constructor", 1, false); // Now, as an additional condition we only show the empty constructor block // IF it was desired to be shown if(!isInterface && pol->getAutoGenerateConstructors()) emptyConstBlock->setWriteOutText(true); else emptyConstBlock->setWriteOutText(false); // METHODS subsection : ACCESSOR METHODS // // get/create the accessor codeblock // public HierarchicalCodeBlock * pubAccessorBlock = pubMethodsBlock->getHierarchicalCodeBlock("accessorMethods", "Accessor Methods", 1); // set conditions for showing section comment CodeComment * pubAccessComment = pubAccessorBlock->getComment(); if (!forcedoc && !hasclassFields) pubAccessComment->setWriteOutText(false); else pubAccessComment->setWriteOutText(true); // protected HierarchicalCodeBlock * protAccessorBlock = protMethodsBlock->getHierarchicalCodeBlock("accessorMethods", "Accessor Methods", 1); // set conditions for showing section comment CodeComment * protAccessComment = protAccessorBlock->getComment(); if (!forcedoc && !hasclassFields) protAccessComment->setWriteOutText(false); else protAccessComment->setWriteOutText(true); // private HierarchicalCodeBlock * privAccessorBlock = privMethodsBlock->getHierarchicalCodeBlock("accessorMethods", "Accessor Methods", 1); // set conditions for showing section comment CodeComment * privAccessComment = privAccessorBlock->getComment(); // We've to copy the private accessorMethods to the public block if (!forcedoc && !hasclassFields) privAccessComment->setWriteOutText(false); else privAccessComment->setWriteOutText(true); // now, 2 sub-sub sections in accessor block // add/update accessor methods for attributes HierarchicalCodeBlock * pubStaticAccessors = pubAccessorBlock->getHierarchicalCodeBlock("pubStaticAccessorMethods", "", 1); HierarchicalCodeBlock * pubRegularAccessors = pubAccessorBlock->getHierarchicalCodeBlock("pubRegularAccessorMethods", "", 1); pubStaticAccessors->getComment()->setWriteOutText(false); // never write block comment pubRegularAccessors->getComment()->setWriteOutText(false); // never write block comment HierarchicalCodeBlock * protStaticAccessors = protAccessorBlock->getHierarchicalCodeBlock("protStaticAccessorMethods", "", 1); HierarchicalCodeBlock * protRegularAccessors = protAccessorBlock->getHierarchicalCodeBlock("protRegularAccessorMethods", "", 1); protStaticAccessors->getComment()->setWriteOutText(false); // never write block comment protRegularAccessors->getComment()->setWriteOutText(false); // never write block comment HierarchicalCodeBlock * privStaticAccessors = privAccessorBlock->getHierarchicalCodeBlock("privStaticAccessorMethods", "", 1); HierarchicalCodeBlock * privRegularAccessors = privAccessorBlock->getHierarchicalCodeBlock("privRegularAccessorMethods", "", 1); privStaticAccessors->getComment()->setWriteOutText(false); // never write block comment privRegularAccessors->getComment()->setWriteOutText(false); // never write block comment // now add in accessors as appropriate // public stuff pubStaticAccessors->addCodeClassFieldMethods(staticPublicAttribClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicAttribClassFields); // generate accessors as public if (policy && policy->getAccessorsArePublic()) { pubRegularAccessors->addCodeClassFieldMethods(privateAttribClassFields); pubRegularAccessors->addCodeClassFieldMethods(protectedAttribClassFields); } pubRegularAccessors->addCodeClassFieldMethods(publicPlainAssocClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicAggregationClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicCompositionClassFields); // protected stuff protStaticAccessors->addCodeClassFieldMethods(staticProtectedAttribClassFields); // accessors are public so we don't have to create it here if (policy && !policy->getAccessorsArePublic()) protRegularAccessors->addCodeClassFieldMethods(protectedAttribClassFields); protRegularAccessors->addCodeClassFieldMethods(protPlainAssocClassFields); protRegularAccessors->addCodeClassFieldMethods(protAggregationClassFields); protRegularAccessors->addCodeClassFieldMethods(protCompositionClassFields); // private stuff privStaticAccessors->addCodeClassFieldMethods(staticPrivateAttribClassFields); // accessors are public so we don't have to create it here if (policy && !policy->getAccessorsArePublic()) privRegularAccessors->addCodeClassFieldMethods(privateAttribClassFields); privRegularAccessors->addCodeClassFieldMethods(privPlainAssocClassFields); privRegularAccessors->addCodeClassFieldMethods(privAggregationClassFields); privRegularAccessors->addCodeClassFieldMethods(privCompositionClassFields); // METHODS subsection : Operation methods (e.g. methods derive from operations but which arent constructors) // // setup/get/create the operations codeblock // public pubOperationsBlock = pubMethodsBlock->getHierarchicalCodeBlock("operationMethods", "Operations", 1); // set conditions for showing section comment CodeComment * pubOcomment = pubOperationsBlock->getComment(); if (!forcedoc && !hasOperationMethods ) pubOcomment->setWriteOutText(false); else pubOcomment->setWriteOutText(true); //protected protOperationsBlock = protMethodsBlock->getHierarchicalCodeBlock("operationMethods", "Operations", 1); // set conditions for showing section comment CodeComment * protOcomment = protOperationsBlock->getComment(); if (!forcedoc && !hasOperationMethods ) protOcomment->setWriteOutText(false); else protOcomment->setWriteOutText(true); //private privOperationsBlock = privMethodsBlock->getHierarchicalCodeBlock("operationMethods", "Operations", 1); // set conditions for showing section comment CodeComment * privOcomment = privOperationsBlock->getComment(); if (!forcedoc && !hasOperationMethods ) privOcomment->setWriteOutText(false); else privOcomment->setWriteOutText(true); // Operations // // nothing to do here.. "updateOperations" in parent class puts things // in the right place using the "addCodeOperation" method we defined in this class // FINISH up with hash def block close QString defTextEnd = "#endif //"+hashDefine + "_H"; addOrUpdateTaggedCodeBlockWithComments("hashDefBlockEnd", defTextEnd, "", 0, false); }
/** * This will be called by syncToParent whenever the parent object is "modified". */ void DCodeClassFieldDeclarationBlock::updateContent() { CodeClassField * cf = getParentClassField(); DCodeClassField * jcf = dynamic_cast<DCodeClassField*>(cf); if (!jcf) { uError() << "jcf: invalid dynamic cast"; return; } CodeGenerationPolicy * commonpolicy = UMLApp::app()->commonPolicy(); Uml::Visibility::Enum scopePolicy = commonpolicy->getAssociationFieldScope(); // Set the comment QString notes = getParentObject()->doc(); getComment()->setText(notes); // Set the body QString staticValue = getParentObject()->isStatic() ? QLatin1String("static ") : QString(); QString scopeStr = Uml::Visibility::toString(getParentObject()->visibility()); // IF this is from an association, then scope taken as appropriate to policy if (!jcf->parentIsAttribute()) { switch (scopePolicy) { case Uml::Visibility::Public: case Uml::Visibility::Private: case Uml::Visibility::Protected: scopeStr = Uml::Visibility::toString(scopePolicy); break; default: case Uml::Visibility::FromParent: // do nothing here... will leave as from parent object break; } } QString typeName = jcf->getTypeName(); QString fieldName = jcf->getFieldName(); QString initialV = jcf->getInitialValue(); if (!cf->parentIsAttribute() && !cf->fieldIsSingleValue()) typeName = QLatin1String("List"); QString body = staticValue + scopeStr + QLatin1Char(' ') + typeName + QLatin1Char(' ') + fieldName; if (!initialV.isEmpty()) body.append(QLatin1String(" = ") + initialV); else if (!cf->parentIsAttribute()) { UMLRole * role = dynamic_cast<UMLRole*>(cf->getParentObject()); // Check for dynamic casting failure! if (role == NULL) { uError() << "role: invalid dynamic cast"; return; } if (role->object()->baseType() == UMLObject::ot_Interface) { // do nothing.. can't instantiate an interface } else { // FIX?: IF a constructor method exists in the classifiercodedoc // of the parent Object, then we can use that instead (if its empty). if(cf->fieldIsSingleValue()) { if(!typeName.isEmpty()) body.append(QLatin1String(" = new ") + typeName + QLatin1String(" ()")); } else body.append(QLatin1String(" = new Vector ()")); } } setText(body + QLatin1Char(';')); }
void RubyCodeAccessorMethod::updateMethodDeclaration() { RubyCodeClassField * rubyfield = dynamic_cast<RubyCodeClassField*>(getParentClassField()); RubyClassifierCodeDocument * rubydoc = dynamic_cast<RubyClassifierCodeDocument*>(rubyfield->getParentDocument()); // gather defs CodeGenerationPolicy *p = UMLApp::app()->getCommonPolicy(); CodeGenerationPolicy::ScopePolicy scopePolicy = p->getAttributeAccessorScope(); QString strVis = rubydoc->scopeToRubyDecl(rubyfield->getVisibility()); QString fieldName = RubyCodeGenerator::cppToRubyName(rubyfield->getFieldName()); QString fieldType = RubyCodeGenerator::cppToRubyType(rubyfield->getTypeName()); QString objectType = rubyfield->getListObjectType(); if(objectType.isEmpty()) objectType = fieldName; QString endLine = p->getNewLineEndingChars(); QString description = getParentObject()->getDoc(); description.replace(QRegExp("m_[npb](?=[A-Z])"), ""); description.replace("m_", ""); description.replace(QRegExp("[\\n\\r]+[\\t ]*"), endLine); // set scope of this accessor appropriately..if its an attribute, // we need to be more sophisticated if(rubyfield->parentIsAttribute()) switch (scopePolicy) { case CodeGenerationPolicy::Public: case CodeGenerationPolicy::Private: case CodeGenerationPolicy::Protected: strVis = rubydoc->scopeToRubyDecl((Uml::Visibility::Value) scopePolicy); break; default: case CodeGenerationPolicy::FromParent: // do nothing..already have taken parent value break; } // some variables we will need to populate QString headerText = ""; QString methodReturnType = ""; QString methodName = ""; QString methodParams = ""; switch(getType()) { case CodeAccessorMethod::ADD: methodName = "add" + Codegen_Utils::capitalizeFirstLetter(fieldType); methodReturnType = ""; methodParams = objectType+" value "; headerText = "Add an object of type "+objectType+" to the Array "+fieldName+endLine+description+endLine+"@return nil"; setStartMethodText("def "+ methodName + '(' + methodParams + ')'); setEndMethodText("end"); break; case CodeAccessorMethod::GET: headerText = "Get the value of " + fieldName + endLine + description; setStartMethodText(QString("attr_reader :") + fieldName); setEndMethodText(""); break; case CodeAccessorMethod::LIST: methodName = "get" + Codegen_Utils::capitalizeFirstLetter(fieldType)+"List"; methodReturnType = ""; headerText = "Get the list of "+fieldName+endLine+description+endLine+"_returns_ List of "+fieldName; setStartMethodText("def "+ methodName + '(' + methodParams + ')'); setEndMethodText("end"); break; case CodeAccessorMethod::REMOVE: methodName = "remove" + Codegen_Utils::capitalizeFirstLetter(fieldType); methodReturnType = ""; methodParams = objectType+" value "; headerText = "Remove an object of type "+objectType+" from the List "+fieldName+endLine+description; setStartMethodText("def "+ methodName + '(' + methodParams + ')'); setEndMethodText("end"); break; case CodeAccessorMethod::SET: headerText = "Set the value of " + fieldName + endLine + description; setStartMethodText(QString("attr_writer :") + fieldName); setEndMethodText(""); break; default: // do nothing..no idea what this is kWarning()<<"Warning: can't generate RubyCodeAccessorMethod for type: "<<getType()<<endl; break; } // set header once. if (getComment()->getText().isEmpty()) getComment()->setText(headerText); }
void JavaCodeAccessorMethod::updateMethodDeclaration() { JavaCodeClassField * javafield = dynamic_cast<JavaCodeClassField*>(getParentClassField()); JavaClassifierCodeDocument * javadoc = dynamic_cast<JavaClassifierCodeDocument*>(javafield->getParentDocument()); CodeGenerationPolicy *commonpolicy = UMLApp::app()->getCommonPolicy(); // gather defs CodeGenerationPolicy::ScopePolicy scopePolicy = commonpolicy->getAttributeAccessorScope(); QString strVis = javadoc->scopeToJavaDecl(javafield->getVisibility()); QString fieldName = javafield->getFieldName(); QString fieldType = javafield->getTypeName(); QString objectType = javafield->getListObjectType(); if(objectType.isEmpty()) objectType = fieldName; QString endLine = UMLApp::app()->getCommonPolicy()->getNewLineEndingChars(); // set scope of this accessor appropriately..if its an attribute, // we need to be more sophisticated if(javafield->parentIsAttribute()) switch (scopePolicy) { case CodeGenerationPolicy::Public: case CodeGenerationPolicy::Private: case CodeGenerationPolicy::Protected: strVis = javadoc->scopeToJavaDecl((Uml::Visibility::Value) scopePolicy); break; default: case CodeGenerationPolicy::FromParent: // do nothing..already have taken parent value break; } // some variables we will need to populate QString headerText = ""; QString methodReturnType = ""; QString methodName = ""; QString methodParams = ""; switch(getType()) { case CodeAccessorMethod::ADD: methodName = "add" + Codegen_Utils::capitalizeFirstLetter(fieldType); methodReturnType = "void"; methodParams = objectType+" value "; headerText = "Add an object of type "+objectType+" to the List "+fieldName+endLine+getParentObject()->getDoc()+endLine+"@return void"; break; case CodeAccessorMethod::GET: methodName = "get" + Codegen_Utils::capitalizeFirstLetter(fieldName); methodReturnType = fieldType; headerText = "Get the value of "+fieldName+endLine+getParentObject()->getDoc()+endLine+"@return the value of "+fieldName; break; case CodeAccessorMethod::LIST: methodName = "get" + Codegen_Utils::capitalizeFirstLetter(fieldType)+"List"; methodReturnType = "List"; headerText = "Get the list of "+fieldName+endLine+getParentObject()->getDoc()+endLine+"@return List of "+fieldName; break; case CodeAccessorMethod::REMOVE: methodName = "remove" + Codegen_Utils::capitalizeFirstLetter(fieldType); methodReturnType = "void"; methodParams = objectType+" value "; headerText = "Remove an object of type "+objectType+" from the List "+fieldName+endLine+getParentObject()->getDoc(); break; case CodeAccessorMethod::SET: methodName = "set" + Codegen_Utils::capitalizeFirstLetter(fieldName); methodReturnType = "void"; methodParams = fieldType + " value "; headerText = "Set the value of "+fieldName+endLine+getParentObject()->getDoc()+endLine; break; default: // do nothing..no idea what this is kWarning()<<"Warning: cant generate JavaCodeAccessorMethod for type: "<<getType()<<endl; break; } // set header once. if(getComment()->getText().isEmpty()) getComment()->setText(headerText); // set start/end method text setStartMethodText(strVis+' '+methodReturnType+' '+methodName+" ( "+methodParams+" ) {"); setEndMethodText("}"); }
// This method will cause the class to rebuild its text representation. // based on the parent classifier object. // For any situation in which this is called, we are either building the code // document up, or replacing/regenerating the existing auto-generated parts. As // such, we will want to insert everything we resonablely will want // during creation. We can set various parts of the document (esp. the // comments) to appear or not, as needed. void RubyClassifierCodeDocument::updateContent() { // Gather info on the various fields and parent objects of this class... UMLClassifier * c = getParentClassifier(); RubyCodeGenerator * gen = dynamic_cast<RubyCodeGenerator*>(UMLApp::app()->generator()); // first, set the global flag on whether or not to show classfield info // This depends on whether or not we have attribute/association classes const CodeClassFieldList * cfList = getCodeClassFieldList(); CodeClassFieldList::const_iterator it = cfList->begin(); CodeClassFieldList::const_iterator end = cfList->end(); for (; it != end; ++it) { CodeClassField * field = *it; if (field->parentIsAttribute()) field->setWriteOutMethods(gen->getAutoGenerateAttribAccessors()); else field->setWriteOutMethods(gen->getAutoGenerateAssocAccessors()); } // attribute-based ClassFields // we do it this way to have the static fields sorted out from regular ones CodeClassFieldList staticPublicAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true, Uml::Visibility::Public); CodeClassFieldList publicAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, false, Uml::Visibility::Public); CodeClassFieldList staticProtectedAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true, Uml::Visibility::Protected); CodeClassFieldList protectedAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, false, Uml::Visibility::Protected); CodeClassFieldList staticPrivateAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true, Uml::Visibility::Private); CodeClassFieldList privateAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, false, Uml::Visibility::Private); // association-based ClassFields // don't care if they are static or not..all are lumped together CodeClassFieldList publicPlainAssocClassFields = getSpecificClassFields (CodeClassField::PlainAssociation, Uml::Visibility::Public); CodeClassFieldList publicAggregationClassFields = getSpecificClassFields (CodeClassField::Aggregation, Uml::Visibility::Public); CodeClassFieldList publicCompositionClassFields = getSpecificClassFields (CodeClassField::Composition, Uml::Visibility::Public); CodeClassFieldList protPlainAssocClassFields = getSpecificClassFields (CodeClassField::PlainAssociation, Uml::Visibility::Protected); CodeClassFieldList protAggregationClassFields = getSpecificClassFields (CodeClassField::Aggregation, Uml::Visibility::Protected); CodeClassFieldList protCompositionClassFields = getSpecificClassFields (CodeClassField::Composition, Uml::Visibility::Protected); CodeClassFieldList privPlainAssocClassFields = getSpecificClassFields (CodeClassField::PlainAssociation, Uml::Visibility::Private); CodeClassFieldList privAggregationClassFields = getSpecificClassFields (CodeClassField::Aggregation, Uml::Visibility::Private); CodeClassFieldList privCompositionClassFields = getSpecificClassFields (CodeClassField::Composition, Uml::Visibility::Private); bool isInterface = parentIsInterface(); bool hasOperationMethods = false; Q_ASSERT(c != NULL); if (c) { UMLOperationList list = c->getOpList(); hasOperationMethods = ! list.isEmpty(); } CodeGenerationPolicy *pol = UMLApp::app()->commonPolicy(); QString endLine = pol->getNewLineEndingChars(); // a shortcut..so we don't have to call this all the time // // START GENERATING CODE/TEXT BLOCKS and COMMENTS FOR THE DOCUMENT // // CLASS DECLARATION BLOCK // // get the declaration block. If it is not already present, add it too RubyClassDeclarationBlock * myClassDeclCodeBlock = getClassDecl(); addTextBlock(myClassDeclCodeBlock); // note: wont add if already present // declare public, protected and private methods, attributes (fields). // set the start text ONLY if this is the first time we created the objects. bool createdPublicBlock = publicBlock == 0 ? true : false; publicBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock(QLatin1String("publicBlock"), QLatin1String("Public Items"), 0); if (createdPublicBlock) publicBlock->setStartText(QLatin1String("public")); bool createdProtBlock = protectedBlock == 0 ? true : false; protectedBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock(QLatin1String("protectedBlock"), QLatin1String("Protected Items"), 0); if (createdProtBlock) protectedBlock->setStartText(QLatin1String("protected")); bool createdPrivBlock = privateBlock == 0 ? true : false; privateBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock(QLatin1String("privateBlock"), QLatin1String("Private Items"), 0); if (createdPrivBlock) privateBlock->setStartText(QLatin1String("private")); // NOW create document in sections.. // now we want to populate the body of our class // our layout is the following general groupings of code blocks: // start ruby classifier document // header comment // class declaration // section: // section: // - methods section comment // sub-section: constructor ops // - constructor method section comment // - constructor methods (0+ codeblocks) // sub-section: accessors // - accessor method section comment // - static accessor methods (0+ codeblocks) // - non-static accessor methods (0+ codeblocks) // sub-section: non-constructor ops // - operation method section comment // - operations (0+ codeblocks) // end class declaration // end ruby classifier document // Q: Why use the more complicated scheme of arranging code blocks within codeblocks? // A: This will allow us later to preserve the format of our document so that if // codeblocks are added, they may be easily added in the correct place, rather than at // the end of the document, or by using a difficult algorithm to find the location of // the last appropriate code block sibling (which may not exist.. for example user adds // a constructor operation, but there currently are no constructor code blocks // within the document). // // METHODS section // // get/create the method codeblock // public methods HierarchicalCodeBlock * pubMethodsBlock = publicBlock->getHierarchicalCodeBlock(QLatin1String("pubMethodsBlock"), QString(), 1); CodeComment * pubMethodsComment = pubMethodsBlock->getComment(); bool forceDoc = pol->getCodeVerboseDocumentComments(); // set conditions for showing this comment if (!forceDoc && !hasClassFields() && !hasOperationMethods) pubMethodsComment->setWriteOutText(false); else pubMethodsComment->setWriteOutText(true); // protected methods HierarchicalCodeBlock * protMethodsBlock = protectedBlock->getHierarchicalCodeBlock(QLatin1String("protMethodsBlock"), QString(), 1); CodeComment * protMethodsComment = protMethodsBlock->getComment(); // set conditions for showing this comment if (!forceDoc && !hasClassFields() && !hasOperationMethods) protMethodsComment->setWriteOutText(false); else protMethodsComment->setWriteOutText(true); // private methods HierarchicalCodeBlock * privMethodsBlock = privateBlock->getHierarchicalCodeBlock(QLatin1String("privMethodsBlock"), QString(), 1); CodeComment * privMethodsComment = privMethodsBlock->getComment(); // set conditions for showing this comment if (!forceDoc && !hasClassFields() && !hasOperationMethods) privMethodsComment->setWriteOutText(false); else privMethodsComment->setWriteOutText(true); // METHODS sub-section : constructor methods // // public pubConstructorBlock = pubMethodsBlock->getHierarchicalCodeBlock(QLatin1String("constructionMethods"), QLatin1String("Constructors"), 1); // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * pubConstComment = pubConstructorBlock->getComment(); if (!forceDoc && (isInterface || !pol->getAutoGenerateConstructors())) pubConstComment->setWriteOutText(false); else pubConstComment->setWriteOutText(true); // protected protConstructorBlock = protMethodsBlock->getHierarchicalCodeBlock(QLatin1String("constructionMethods"), QLatin1String("Constructors"), 1); // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * protConstComment = protConstructorBlock->getComment(); if (!forceDoc && (isInterface || !pol->getAutoGenerateConstructors())) protConstComment->setWriteOutText(false); else protConstComment->setWriteOutText(true); // private privConstructorBlock = privMethodsBlock->getHierarchicalCodeBlock(QLatin1String("constructionMethods"), QLatin1String("Constructors"), 1); // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * privConstComment = privConstructorBlock->getComment(); if (!forceDoc && (isInterface || !pol->getAutoGenerateConstructors())) privConstComment->setWriteOutText(false); else privConstComment->setWriteOutText(true); // get/create the accessor codeblock // public HierarchicalCodeBlock * pubAccessorBlock = pubMethodsBlock->getHierarchicalCodeBlock(QLatin1String("accessorMethods"), QLatin1String("Accessor Methods"), 1); // set conditions for showing section comment CodeComment * pubAccessComment = pubAccessorBlock->getComment(); if (!forceDoc && !hasClassFields()) pubAccessComment->setWriteOutText(false); else pubAccessComment->setWriteOutText(true); // protected HierarchicalCodeBlock * protAccessorBlock = protMethodsBlock->getHierarchicalCodeBlock(QLatin1String("accessorMethods"), QLatin1String("Accessor Methods"), 1); // set conditions for showing section comment CodeComment * protAccessComment = protAccessorBlock->getComment(); if (!forceDoc && !hasClassFields()) protAccessComment->setWriteOutText(false); else protAccessComment->setWriteOutText(true); // private HierarchicalCodeBlock * privAccessorBlock = privMethodsBlock->getHierarchicalCodeBlock(QLatin1String("accessorMethods"), QLatin1String("Accessor Methods"), 1); // set conditions for showing section comment CodeComment * privAccessComment = privAccessorBlock->getComment(); if (!forceDoc && !hasClassFields()) privAccessComment->setWriteOutText(false); else privAccessComment->setWriteOutText(true); // now, 2 sub-sub sections in accessor block // add/update accessor methods for attributes HierarchicalCodeBlock * pubStaticAccessors = pubAccessorBlock->getHierarchicalCodeBlock(QLatin1String("pubStaticAccessorMethods"), QString(), 1); HierarchicalCodeBlock * pubRegularAccessors = pubAccessorBlock->getHierarchicalCodeBlock(QLatin1String("pubRegularAccessorMethods"), QString(), 1); pubStaticAccessors->getComment()->setWriteOutText(false); // never write block comment pubRegularAccessors->getComment()->setWriteOutText(false); // never write block comment HierarchicalCodeBlock * protStaticAccessors = protAccessorBlock->getHierarchicalCodeBlock(QLatin1String("protStaticAccessorMethods"), QString(), 1); HierarchicalCodeBlock * protRegularAccessors = protAccessorBlock->getHierarchicalCodeBlock(QLatin1String("protRegularAccessorMethods"), QString(), 1); protStaticAccessors->getComment()->setWriteOutText(false); // never write block comment protRegularAccessors->getComment()->setWriteOutText(false); // never write block comment HierarchicalCodeBlock * privStaticAccessors = privAccessorBlock->getHierarchicalCodeBlock(QLatin1String("privStaticAccessorMethods"), QString(), 1); HierarchicalCodeBlock * privRegularAccessors = privAccessorBlock->getHierarchicalCodeBlock(QLatin1String("privRegularAccessorMethods"), QString(), 1); privStaticAccessors->getComment()->setWriteOutText(false); // never write block comment privRegularAccessors->getComment()->setWriteOutText(false); // never write block comment // now add in accessors as appropriate // public stuff pubStaticAccessors->addCodeClassFieldMethods(staticPublicAttribClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicAttribClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicPlainAssocClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicAggregationClassFields); pubRegularAccessors->addCodeClassFieldMethods(publicCompositionClassFields); // protected stuff protStaticAccessors->addCodeClassFieldMethods(staticProtectedAttribClassFields); protRegularAccessors->addCodeClassFieldMethods(protectedAttribClassFields); protRegularAccessors->addCodeClassFieldMethods(protPlainAssocClassFields); protRegularAccessors->addCodeClassFieldMethods(protAggregationClassFields); protRegularAccessors->addCodeClassFieldMethods(protCompositionClassFields); // private stuff privStaticAccessors->addCodeClassFieldMethods(staticPrivateAttribClassFields); privRegularAccessors->addCodeClassFieldMethods(privateAttribClassFields); privRegularAccessors->addCodeClassFieldMethods(privPlainAssocClassFields); privRegularAccessors->addCodeClassFieldMethods(privAggregationClassFields); privRegularAccessors->addCodeClassFieldMethods(privCompositionClassFields); // METHODS subsection : Operation methods (which aren't constructors) // // setup/get/create the operations codeblock // public pubOperationsBlock = pubMethodsBlock->getHierarchicalCodeBlock(QLatin1String("operationMethods"), QLatin1String("Operations"), 1); // set conditions for showing section comment CodeComment * pubOcomment = pubOperationsBlock->getComment(); if (!forceDoc && !hasOperationMethods) pubOcomment->setWriteOutText(false); else pubOcomment->setWriteOutText(true); //protected protOperationsBlock = protMethodsBlock->getHierarchicalCodeBlock(QLatin1String("operationMethods"), QLatin1String("Operations"), 1); // set conditions for showing section comment CodeComment * protOcomment = protOperationsBlock->getComment(); if (!forceDoc && !hasOperationMethods) protOcomment->setWriteOutText(false); else protOcomment->setWriteOutText(true); //private privOperationsBlock = privMethodsBlock->getHierarchicalCodeBlock(QLatin1String("operationMethods"), QLatin1String("Operations"), 1); // set conditions for showing section comment CodeComment * privOcomment = privOperationsBlock->getComment(); if (!forceDoc && !hasOperationMethods) privOcomment->setWriteOutText(false); else privOcomment->setWriteOutText(true); }
// This method will cause the class to rebuild its text representation. // based on the parent classifier object. // For any situation in which this is called, we are either building the code // document up, or replacing/regenerating the existing auto-generated parts. As // such, we will want to insert everything we resonablely will want // during creation. We can set various parts of the document (esp. the // comments) to appear or not, as needed. void DClassifierCodeDocument::updateContent() { // Gather info on the various fields and parent objects of this class... UMLClassifier * c = getParentClassifier(); Q_ASSERT(c != 0); CodeGenerationPolicy * commonPolicy = UMLApp::app()->commonPolicy(); CodeGenPolicyExt * pe = UMLApp::app()->policyExt(); DCodeGenerationPolicy * policy = dynamic_cast<DCodeGenerationPolicy*>(pe); // first, set the global flag on whether or not to show classfield info // This depends on whether or not we have attribute/association classes const CodeClassFieldList * cfList = getCodeClassFieldList(); CodeClassFieldList::const_iterator it = cfList->begin(); CodeClassFieldList::const_iterator end = cfList->end(); for (; it != end; ++it) { CodeClassField * field = *it; if (field->parentIsAttribute()) field->setWriteOutMethods(policy->getAutoGenerateAttribAccessors()); else field->setWriteOutMethods(policy->getAutoGenerateAssocAccessors()); } // attribute-based ClassFields // we do it this way to have the static fields sorted out from regular ones CodeClassFieldList staticAttribClassFields = getSpecificClassFields (CodeClassField::Attribute, true); CodeClassFieldList attribClassFields = getSpecificClassFields (CodeClassField::Attribute, false); // association-based ClassFields // don't care if they are static or not..all are lumped together CodeClassFieldList plainAssocClassFields = getSpecificClassFields (CodeClassField::PlainAssociation); CodeClassFieldList aggregationClassFields = getSpecificClassFields (CodeClassField::Aggregation); CodeClassFieldList compositionClassFields = getSpecificClassFields (CodeClassField::Composition); bool isInterface = parentIsInterface(); bool hasOperationMethods = false; UMLOperationList list = c->getOpList(); hasOperationMethods = ! list.isEmpty(); QString endLine = commonPolicy->getNewLineEndingChars(); // a shortcut..so we don't have to call this all the time // // START GENERATING CODE/TEXT BLOCKS and COMMENTS FOR THE DOCUMENT // // // PACKAGE CODE BLOCK // QString pkgs = getPackage(); pkgs.replace(QRegExp(QLatin1String("::")), QLatin1String(".")); QString packageText = getPackage().isEmpty() ? QString() : QString(QLatin1String("package ")+pkgs+QLatin1Char(';')+endLine); CodeBlockWithComments * pblock = addOrUpdateTaggedCodeBlockWithComments(QLatin1String("packages"), packageText, QString(), 0, false); if (packageText.isEmpty() && pblock->contentType() == CodeBlock::AutoGenerated) pblock->setWriteOutText(false); else pblock->setWriteOutText(true); // IMPORT CODEBLOCK // // Q: Why all utils? Aren't just List and Vector the only classes we are using? // A: doesn't matter at all; it is more readable to just include '*' and d compilers // don't slow down or anything. (TZ) QString importStatement; if (hasObjectVectorClassFields()) importStatement.append(QLatin1String("import d.util.*;")); //only import classes in a different package from this class UMLPackageList imports; QMap<UMLPackage*, QString> packageMap; // so we don't repeat packages CodeGenerator::findObjectsRelated(c, imports); for (UMLPackageListIt importsIt(imports); importsIt.hasNext();) { UMLPackage *con = importsIt.next(); // NO (default) datatypes in the import statement.. use defined // ones whould be possible, but no idea how to do that...at least for now. // Dynamic casting is slow..not an optimal way to do this. if (!packageMap.contains(con) && !con->isUMLDatatype()) { packageMap.insert(con, con->package()); // now, we DON'T need to import classes that are already in our own package // (that is, IF a package is specified). Otherwise, we should have a declaration. if (con->package() != c->package() || (c->package().isEmpty() && con->package().isEmpty())) { importStatement.append(endLine+QLatin1String("import ")); if (!con->package().isEmpty()) importStatement.append(con->package()+QLatin1Char('.')); importStatement.append(CodeGenerator::cleanName(con->name())+QLatin1Char(';')); } } } // now, add/update the imports codeblock CodeBlockWithComments * iblock = addOrUpdateTaggedCodeBlockWithComments(QLatin1String("imports"), importStatement, QString(), 0, false); if (importStatement.isEmpty() && iblock->contentType() == CodeBlock::AutoGenerated) iblock->setWriteOutText(false); else iblock->setWriteOutText(true); // CLASS DECLARATION BLOCK // // get the declaration block. If it is not already present, add it too DClassDeclarationBlock * myClassDeclCodeBlock = getClassDecl(); addTextBlock(myClassDeclCodeBlock); // note: wont add if already present // NOW create document in sections.. // now we want to populate the body of our class // our layout is the following general groupings of code blocks: // start d classifier document // header comment // package code block // import code block // class declaration // section: // - class field declaration section comment // - class field declarations (0+ codeblocks) // section: // - methods section comment // sub-section: constructor ops // - constructor method section comment // - constructor methods (0+ codeblocks) // sub-section: accessors // - accessor method section comment // - static accessor methods (0+ codeblocks) // - non-static accessor methods (0+ codeblocks) // sub-section: non-constructor ops // - operation method section comment // - operations (0+ codeblocks) // end class declaration // end d classifier document // Q: Why use the more complicated scheme of arranging code blocks within codeblocks? // A: This will allow us later to preserve the format of our document so that if // codeblocks are added, they may be easily added in the correct place, rather than at // the end of the document, or by using a difficult algorithm to find the location of // the last appropriate code block sibling (which may not exist.. for example user adds // a constructor operation, but there currently are no constructor code blocks // within the document). // // * CLASS FIELD declaration section // // get/create the field declaration code block HierarchicalCodeBlock * fieldDeclBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock(QLatin1String("fieldsDecl"), QLatin1String("Fields"), 1); // Update the comment: we only set comment to appear under the following conditions CodeComment * fcomment = fieldDeclBlock->getComment(); if (isInterface || (!forceDoc() && !hasClassFields())) fcomment->setWriteOutText(false); else fcomment->setWriteOutText(true); // now actually declare the fields within the appropriate HCodeBlock declareClassFields(staticAttribClassFields, fieldDeclBlock); declareClassFields(attribClassFields, fieldDeclBlock); declareClassFields(plainAssocClassFields, fieldDeclBlock); declareClassFields(aggregationClassFields, fieldDeclBlock); declareClassFields(compositionClassFields, fieldDeclBlock); // // METHODS section // // get/create the method codeblock HierarchicalCodeBlock * methodsBlock = myClassDeclCodeBlock->getHierarchicalCodeBlock(QLatin1String("methodsBlock"), QLatin1String("Methods"), 1); // Update the section comment CodeComment * methodsComment = methodsBlock->getComment(); // set conditions for showing this comment if (!forceDoc() && !hasClassFields() && !hasOperationMethods) methodsComment->setWriteOutText(false); else methodsComment->setWriteOutText(true); // METHODS sub-section : constructor methods // // get/create the constructor codeblock HierarchicalCodeBlock * constBlock = methodsBlock->getHierarchicalCodeBlock(QLatin1String("constructorMethods"), QLatin1String("Constructors"), 1); constructorBlock = constBlock; // record this codeblock for later, when operations are updated // special condiions for showing comment: only when autogenerateding empty constructors // Although, we *should* check for other constructor methods too CodeComment * constComment = constBlock->getComment(); CodeGenerationPolicy *pol = UMLApp::app()->commonPolicy(); if (!forceDoc() && (isInterface || !pol->getAutoGenerateConstructors())) constComment->setWriteOutText(false); else constComment->setWriteOutText(true); // add/get the empty constructor QString DClassName = getDClassName(c->name()); QString emptyConstStatement = QLatin1String("public ")+DClassName+QLatin1String(" () { }"); CodeBlockWithComments * emptyConstBlock = constBlock->addOrUpdateTaggedCodeBlockWithComments(QLatin1String("emptyconstructor"), emptyConstStatement, QLatin1String("Empty Constructor"), 1, false); // Now, as an additional condition we only show the empty constructor block // IF it was desired to be shown if (parentIsClass() && pol->getAutoGenerateConstructors()) emptyConstBlock->setWriteOutText(true); else emptyConstBlock->setWriteOutText(false); // METHODS subsection : ACCESSOR METHODS // // get/create the accessor codeblock HierarchicalCodeBlock * accessorBlock = methodsBlock->getHierarchicalCodeBlock(QLatin1String("accessorMethods"), QLatin1String("Accessor Methods"), 1); // set conditions for showing section comment CodeComment * accessComment = accessorBlock->getComment(); if (!forceDoc() && !hasClassFields()) accessComment->setWriteOutText(false); else accessComment->setWriteOutText(true); // now, 2 sub-sub sections in accessor block // add/update accessor methods for attributes HierarchicalCodeBlock * staticAccessors = accessorBlock->getHierarchicalCodeBlock(QLatin1String("staticAccessorMethods"), QString(), 1); staticAccessors->getComment()->setWriteOutText(false); // never write block comment staticAccessors->addCodeClassFieldMethods(staticAttribClassFields); staticAccessors->addCodeClassFieldMethods(attribClassFields); // add/update accessor methods for associations HierarchicalCodeBlock * regularAccessors = accessorBlock->getHierarchicalCodeBlock(QLatin1String("regularAccessorMethods"), QString(), 1); regularAccessors->getComment()->setWriteOutText(false); // never write block comment regularAccessors->addCodeClassFieldMethods(plainAssocClassFields); regularAccessors->addCodeClassFieldMethods(aggregationClassFields); regularAccessors->addCodeClassFieldMethods(compositionClassFields); // METHODS subsection : Operation methods (which arent constructors) // // get/create the operations codeblock operationsBlock = methodsBlock->getHierarchicalCodeBlock(QLatin1String("operationMethods"), QLatin1String("Operations"), 1); // set conditions for showing section comment CodeComment * ocomment = operationsBlock->getComment(); if (!forceDoc() && !hasOperationMethods) ocomment->setWriteOutText(false); else ocomment->setWriteOutText(true); }