/**
* @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);
}
