/**
* Call this method to generate Pascal code for a UMLClassifier.
* @param c the class to generate code for
*/
void PascalWriter::writeClass(UMLClassifier *c)
{
if (!c) {
uDebug() << "Cannot write class of NULL concept!";
return;
}
const bool isClass = !c->isInterface();
QString classname = cleanName(c->name());
QString fileName = qualifiedName(c).toLower();
fileName.replace(QLatin1Char('.'), QLatin1Char('-'));
//find an appropriate name for our file
fileName = overwritableName(c, fileName, QLatin1String(".pas"));
if (fileName.isEmpty()) {
emit codeGenerated(c, false);
return;
}
QFile file;
if (!openFile(file, fileName)) {
emit codeGenerated(c, false);
return;
}
// Start generating the code.
QTextStream pas(&file);
//try to find a heading file(license, comments, etc)
QString str;
str = getHeadingFile(QLatin1String(".pas"));
if (!str.isEmpty()) {
str.replace(QRegExp(QLatin1String("%filename%")), fileName);
str.replace(QRegExp(QLatin1String("%filepath%")), file.fileName());
pas << str << endl;
}
QString unit = qualifiedName(c);
pas << "unit " << unit << ";" << m_endl << m_endl;
pas << "INTERFACE" << m_endl << m_endl;
// Use referenced classes.
UMLPackageList imports;
findObjectsRelated(c, imports);
if (imports.count()) {
pas << "uses" << m_endl;
bool first = true;
foreach (UMLPackage* con, imports) {
if (con->baseType() != UMLObject::ot_Datatype) {
if (first)
first = false;
else
pas << "," << m_endl;
pas << " " << qualifiedName(con);
}
}
pas << ";" << m_endl << m_endl;
}
/**
* Return a list of the packages in which this class is embedded.
* The outermost package is first in the list.
*
* @param includeRoot Whether to prefix the root folder name.
* Default: false.
* @return UMLPackageList of the containing packages.
*/
UMLPackageList UMLObject::packages(bool includeRoot) const
{
UMLPackageList pkgList;
UMLPackage* pkg = m_pUMLPackage;
while (pkg != NULL) {
pkgList.prepend(pkg);
pkg = pkg->umlPackage();
}
if (!includeRoot)
pkgList.removeFirst();
return pkgList;
}
void JSWriter::writeClass(UMLClassifier *c)
{
if(!c)
{
kDebug()<<"Cannot write class of NULL concept!" << endl;
return;
}
QString classname = cleanName(c->getName());
QString fileName = c->getName().lower();
//find an appropriate name for our file
fileName = findFileName(c,".js");
if (fileName.isEmpty())
{
emit codeGenerated(c, false);
return;
}
QFile filejs;
if(!openFile(filejs, fileName))
{
emit codeGenerated(c, false);
return;
}
QTextStream js(&filejs);
//////////////////////////////
//Start generating the code!!
/////////////////////////////
//try to find a heading file (license, coments, etc)
QString str;
str = getHeadingFile(".js");
if(!str.isEmpty())
{
str.replace(QRegExp("%filename%"),fileName);
str.replace(QRegExp("%filepath%"),filejs.name());
js << str << m_endl;
}
//write includes
UMLPackageList includes;
findObjectsRelated(c,includes);
for (UMLPackage *conc = includes.first(); conc; conc = includes.next())
{
QString headerName = findFileName(conc, ".js");
if ( !headerName.isEmpty() )
{
js << "#include \"" << headerName << "\"" << m_endl;
}
}
js << m_endl;
//Write class Documentation if there is somthing or if force option
if(forceDoc() || !c->getDoc().isEmpty())
{
js << m_endl << "/**" << m_endl;
js << " * class " << classname << m_endl;
js << formatDoc(c->getDoc()," * ");
js << " */" << m_endl << m_endl;
}
//check if class is abstract and / or has abstract methods
if(c->getAbstract() && !hasAbstractOps(c))
js << "/******************************* Abstract Class ****************************" << m_endl << " "
<< classname << " does not have any pure virtual methods, but its author" << m_endl
<< " defined it as an abstract class, so you should not use it directly." << m_endl
<< " Inherit from it instead and create only objects from the derived classes" << m_endl
<< "*****************************************************************************/" << m_endl << m_endl;
js << classname << " = function ()" << m_endl;
js << "{" << m_endl;
js << m_indentation << "this._init ();" << m_endl;
js << "}" << m_endl;
js << m_endl;
UMLClassifierList superclasses = c->getSuperClasses();
for (UMLClassifier *obj = superclasses.first();
obj; obj = superclasses.next()) {
js << classname << ".prototype = new " << cleanName(obj->getName()) << " ();" << m_endl;
}
js << m_endl;
if (! c->isInterface()) {
UMLAttributeList atl = c->getAttributeList();
js << "/**" << m_endl;
QString temp = "_init sets all " + classname + " attributes to their default value."
" Make sure to call this method within your class constructor";
js << formatDoc(temp, " * ");
js << " */" << m_endl;
js << classname << ".prototype._init = function ()" << m_endl;
js << "{" << m_endl;
for(UMLAttribute *at = atl.first(); at ; at = atl.next())
{
if (forceDoc() || !at->getDoc().isEmpty())
{
js << m_indentation << "/**" << m_endl
<< formatDoc(at->getDoc(), m_indentation + " * ")
<< m_indentation << " */" << m_endl;
}
if(!at->getInitialValue().isEmpty())
{
js << m_indentation << "this.m_" << cleanName(at->getName()) << " = " << at->getInitialValue() << ";" << m_endl;
}
else
{
js << m_indentation << "this.m_" << cleanName(at->getName()) << " = \"\";" << m_endl;
}
}
}
//associations
UMLAssociationList aggregations = c->getAggregations();
if (forceSections() || !aggregations.isEmpty ())
{
js << m_endl << m_indentation << "/**Aggregations: */" << m_endl;
writeAssociation(classname, aggregations , js );
}
UMLAssociationList compositions = c->getCompositions();
if( forceSections() || !compositions.isEmpty())
{
js << m_endl << m_indentation << "/**Compositions: */" << m_endl;
writeAssociation(classname, compositions , js );
}
js << m_endl;
js << "}" << m_endl;
js << m_endl;
//operations
UMLOperationList ops(c->getOpList());
writeOperations(classname, &ops, js);
js << m_endl;
//finish file
//close files and notfiy we are done
filejs.close();
emit codeGenerated(c, true);
}
void CSharpWriter::writeClass(UMLClassifier *c) {
if (!c) {
kDebug()<<"Cannot write class of NULL concept!" << endl;
return;
}
QString classname = cleanName(c->getName());
//find an appropriate name for our file
QString fileName = findFileName(c, ".cs");
if (fileName.isEmpty()) {
emit codeGenerated(c, false);
return;
}
QFile filecs;
if (!openFile(filecs, fileName)) {
emit codeGenerated(c, false);
return;
}
QTextStream cs(&filecs);
//////////////////////////////
//Start generating the code!!
/////////////////////////////
//try to find a heading file (license, coments, etc)
QString str;
str = getHeadingFile(".cs");
if (!str.isEmpty()) {
str.replace(QRegExp("%filename%"),fileName);
str.replace(QRegExp("%filepath%"),filecs.name());
cs<<str<<m_endl;
}
UMLDoc *umldoc = UMLApp::app()->getDocument();
UMLFolder *logicalView = umldoc->getRootFolder(Uml::mt_Logical);
// write generic includes
cs << "using System;" << m_endl;
cs << "using System.Text;" << m_endl;
cs << "using System.Collections;" << m_endl;
cs << "using System.Collections.Generic;" << m_endl << m_endl;
//write includes and namespace
UMLPackage *container = c->getUMLPackage();
if (container == logicalView)
container = NULL;
UMLPackageList includes;
findObjectsRelated(c, includes);
m_seenIncludes.clear();
//m_seenIncludes.append(logicalView);
if (includes.count()) {
UMLPackage *p;
for (UMLPackageListIt it(includes); (p = it.current()) != NULL; ++it) {
UMLClassifier *cl = dynamic_cast<UMLClassifier*>(p);
if (cl)
p = cl->getUMLPackage();
if (p != logicalView && m_seenIncludes.findRef(p) == -1 && p != container) {
cs << "using " << p->getFullyQualifiedName(".") << ";" << m_endl;
m_seenIncludes.append(p);
}
}
cs << m_endl;
}
m_container_indent = "";
if (container) {
cs << "namespace " << container->getFullyQualifiedName(".") << m_endl;
cs << "{" << m_endl << m_endl;
m_container_indent = m_indentation;
m_seenIncludes.append(container);
}
//Write class Documentation if there is somthing or if force option
if (forceDoc() || !c->getDoc().isEmpty()) {
cs << m_container_indent << "/// <summary>" << m_endl;
cs << formatDoc(c->getDoc(), m_container_indent + "/// " );
cs << m_container_indent << "/// </summary>" << m_endl ;
}
UMLClassifierList superclasses = c->getSuperClasses();
UMLAssociationList aggregations = c->getAggregations();
UMLAssociationList compositions = c->getCompositions();
UMLAssociationList realizations = c->getRealizations();
bool isInterface = c->isInterface();
m_unnamedRoles = 1;
cs << m_container_indent << "public ";
//check if it is an interface or regular class
if (isInterface) {
cs << "interface " << classname;
} else {
//check if class is abstract and / or has abstract methods
if (c->getAbstract() || c->hasAbstractOps())
cs << "abstract ";
cs << "class " << classname << (superclasses.count() > 0 ? " : ":"");
// write baseclass, ignore interfaces, write error on multiple inheritance
if (superclasses.count() > 0) {
UMLClassifier *obj;
int supers = 0;
for (obj = superclasses.first(); obj; obj = superclasses.next()) {
if (!obj->isInterface()) {
if (supers > 0) {
cs << " // AND ";
}
cs << cleanName(obj->getName());
supers++;
}
}
if (supers > 1) {
cs << m_endl << "//WARNING: C# does not support multiple inheritance but there is more than 1 superclass defined in your UML model!" << m_endl;
}
}
//check for realizations
UMLAssociationList realizations = c->getRealizations();
UMLAssociation *a;
if (!realizations.isEmpty()) {
for (a = realizations.first(); a; a = realizations.next()) {
UMLClassifier *real = (UMLClassifier*)a->getObject(Uml::B);
if(real != c) {
// write list of realizations
cs << ", " << real->getName();
}
}
}
}
cs << m_endl << m_container_indent << '{' << m_endl;
//associations
if (forceSections() || !aggregations.isEmpty()) {
cs << m_endl << m_container_indent << m_indentation << "#region Aggregations" << m_endl << m_endl;
writeAssociatedAttributes(aggregations, c, cs);
cs << m_endl << m_container_indent << m_indentation << "#endregion" << m_endl;
}
//compositions
if (forceSections() || !compositions.isEmpty()) {
cs << m_endl << m_container_indent << m_indentation << "#region Compositions" << m_endl << m_endl;
writeAssociatedAttributes(compositions, c, cs);
cs << m_endl << m_container_indent << m_indentation << "#endregion" << m_endl;
}
//attributes
// FIXME: C# allows Properties in interface!
if (!isInterface)
writeAttributes(c, cs);
//operations
writeOperations(c, cs);
//finish file
cs << m_endl << m_container_indent << "}" << m_endl << m_endl; // close class
if (container) {
cs << "} // end of namespace "
<< container->getFullyQualifiedName(".") << m_endl << m_endl;
}
//close files and notfiy we are done
filecs.close();
emit codeGenerated(c, 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 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);
}
