/**
* Call this method to generate C++ code for a UMLClassifier.
* @param c the class you want to generate code for
*/
void PythonWriter::writeClass(UMLClassifier *c)
{
if (!c) {
uDebug() << "Cannot write class of NULL concept!";
return;
}
QString classname = cleanName(c->name());
UMLClassifierList superclasses = c->getSuperClasses();
UMLAssociationList aggregations = c->getAggregations();
UMLAssociationList compositions = c->getCompositions();
m_bNeedPass = true;
//find an appropriate name for our file
QString fileName = findFileName(c, QLatin1String(".py"));
if (fileName.isEmpty()) {
emit codeGenerated(c, false);
return;
}
QFile fileh;
if (!openFile(fileh, fileName)) {
emit codeGenerated(c, false);
return;
}
QTextStream h(&fileh);
//////////////////////////////
//Start generating the code!!
/////////////////////////////
//try to find a heading file (license, coments, etc)
QString str;
str = getHeadingFile(QLatin1String(".py"));
if (!str.isEmpty()) {
str.replace(QRegExp(QLatin1String("%filename%")), fileName);
str.replace(QRegExp(QLatin1String("%filepath%")), fileh.fileName());
h<<str<<m_endl;
}
h << "# coding=" << h.codec()->name() << m_endl;
// generate import statement for superclasses and take packages into account
str = cleanName(c->name());
QString pkg = cleanName(c->package());
if (!pkg.isEmpty())
str.prepend(pkg + QLatin1Char('.'));
QStringList includesList = QStringList(str); //save imported classes
int i = superclasses.count();
foreach (UMLClassifier *classifier, superclasses) {
str = cleanName(classifier->name());
pkg = cleanName(classifier->package());
if (!pkg.isEmpty())
str.prepend(pkg + QLatin1Char('.'));
includesList.append(str);
h << "from " << str << " import *" << m_endl;
i--;
}
void TclWriter::writeHeaderFile(UMLClassifier * c, QFile & fileh)
{
// open stream for writing
QTextStream stream(&fileh);
mStream = &stream;
// reset the indent level
m_indentLevel = 0;
// write header blurb
QString str = getHeadingFile(".tcl");
if (!str.isEmpty()) {
str.replace(QRegExp("%filename%"), fileName_);
str.replace(QRegExp("%filepath%"), fileh.fileName());
writeCode(str);
}
// set current namespace
writeCode("namespace eval " + mNamespace + " {");
m_indentLevel++;
// check on already existing
writeComm("Do not load twice");
writeCode("if {[namespace exist " + className_ + "]} return");
// source used superclass files
UMLClassifierList superclasses = c->getSuperClasses();
if (superclasses.count() > 0) {
writeComm
("Source found and used class files and import class command if necessary");
foreach (UMLClassifier * classifier , superclasses ) {
writeUse(classifier);
}
void CSharpWriter::writeOverridesRecursive(UMLClassifierList *superclasses, QTextStream &cs) {
// oplist for implemented abstract operations
UMLOperationList opabstract;
opabstract.setAutoDelete(false);
UMLClassifier *obj;
for (obj = superclasses->first(); obj; obj = superclasses->next()) {
if (!obj->isInterface() && obj->hasAbstractOps()) {
// collect abstract ops
UMLOperationList opl(obj->getOpList());
for (UMLOperation *op = opl.first(); op ; op = opl.next()) {
if (op->getAbstract()) {
opabstract.append(op);
}
}
// write abstract implementations
cs << m_endl << m_container_indent << m_indentation << "#region " << obj->getName() << " members" << m_endl << m_endl;
writeOperations(opabstract,cs,false,true,true);
cs << m_container_indent << m_indentation << "#endregion" << m_endl << m_endl;
opabstract.clear();
}
// Recurse to parent superclasses
UMLClassifierList superRecursive = obj->getSuperClasses();
UMLClassifierList *superRecursivePtr =& superRecursive;
if (superRecursivePtr->count() > 0) {
writeOverridesRecursive(superRecursivePtr, cs);
}
}
}
void XMLSchemaWriter::writeAbstractClassifier (UMLClassifier *c, QTextStream &XMLschema)
{
// preparations
UMLClassifierList subclasses = c->findSubClassConcepts(); // list of what inherits from us
UMLClassifierList superclasses = c->findSuperClassConcepts(); // list of what we inherit from
// write the main declaration
writeConcreteClassifier (c, XMLschema);
writeGroupClassifierDecl (c, subclasses, XMLschema);
markAsWritten(c);
// now go back and make sure all sub-classing nodes are declared
if(subclasses.count() > 0)
{
QString elementName = getElementName(c);
UMLAttributeList attribs = findAttributes(c);
QStringList attribGroups = findAttributeGroups(c);
writeAttributeGroupDecl(elementName, attribs, XMLschema);
// now write out inheriting classes, as needed
for(UMLClassifier * classifier = subclasses.first(); classifier; classifier = subclasses.next())
writeClassifier(classifier, XMLschema);
}
// write out any superclasses as needed
for(UMLClassifier *classifier = superclasses.first(); classifier; classifier = superclasses.next())
writeClassifier(classifier, XMLschema);
}
/**
* Inserts @p type into the type-combobox as well as its completion object.
*/
void UMLEntityAttributeDialog::insertTypesSorted(const QString& type)
{
QStringList types;
// add the data types
UMLDoc * pDoc = UMLApp::app()->document();
UMLClassifierList dataTypes = pDoc->datatypes();
if (dataTypes.count() == 0) {
// Switch to SQL as the active language if no datatypes are set.
UMLApp::app()->setActiveLanguage(Uml::ProgrammingLanguage::SQL);
pDoc->addDefaultDatatypes();
qApp->processEvents();
dataTypes = pDoc->datatypes();
}
foreach (UMLClassifier* dat, dataTypes) {
types << dat->name();
}
// add the given parameter
if (!types.contains(type)) {
types << type;
}
types.sort();
m_pTypeCB->clear();
m_pTypeCB->insertItems(-1, types);
// select the given parameter
int currentIndex = m_pTypeCB->findText(type);
if (currentIndex > -1) {
m_pTypeCB->setCurrentIndex(currentIndex);
}
m_pTypeCB->completionObject()->addItem(type);
}
bool PerlWriter::GetUseStatements(UMLClassifier *c, QString &Ret,
QString &ThisPkgName)
{
if (!c){
return(false);
}
UMLPackageList includes;
findObjectsRelated(c,includes);
QString AV = QChar('@');
QString SV = QChar('$');
QString HV = QChar('%');
foreach (UMLPackage* conc, includes ) {
if (conc->baseType() == Uml::ot_Datatype)
continue;
QString neatName = cleanName(conc->name());
if (neatName != AV && neatName != SV && neatName != HV) {
QString OtherPkgName = conc->package(".");
OtherPkgName.replace(QRegExp("\\."),"::");
QString OtherName = OtherPkgName + "::" + cleanName(conc->name());
// Only print out the use statement if the other package isn't the
// same as the one we are working on. (This happens for the
// "Singleton" design pattern.)
if (OtherName != ThisPkgName){
Ret += "use ";
Ret += OtherName;
Ret += ';';
Ret += m_endl;
}
}
}
UMLClassifierList superclasses = c->getSuperClasses();
if (superclasses.count()) {
Ret += m_endl;
Ret += "use base qw( ";
foreach (UMLClassifier *obj , superclasses ) {
QString packageName = obj->package(".");
packageName.replace(QRegExp("\\."),"::");
Ret += packageName + "::" + cleanName(obj->name()) + ' ';
}
void CSharpWriter::writeOperations(UMLClassifier *c, QTextStream &cs) {
//Lists to store operations sorted by scope
UMLOperationList oppub,opprot,oppriv;
bool isInterface = c->isInterface();
bool generateErrorStub = true;
oppub.setAutoDelete(false);
opprot.setAutoDelete(false);
oppriv.setAutoDelete(false);
//sort operations by scope first and see if there are abstract methods
UMLOperationList opl(c->getOpList());
for (UMLOperation *op = opl.first(); op ; op = opl.next()) {
switch (op->getVisibility()) {
case Uml::Visibility::Public:
oppub.append(op);
break;
case Uml::Visibility::Protected:
opprot.append(op);
break;
case Uml::Visibility::Private:
oppriv.append(op);
break;
default:
break;
}
}
// write realizations (recursive)
UMLAssociationList realizations = c->getRealizations();
if (!isInterface && !realizations.isEmpty()) {
writeRealizationsRecursive(c, &realizations, cs);
}
// write public operations
if (forceSections() || !oppub.isEmpty()) {
cs << m_endl << m_container_indent << m_indentation << "#region Public methods" << m_endl << m_endl;
writeOperations(oppub,cs,isInterface,false,generateErrorStub);
cs << m_container_indent << m_indentation << "#endregion" << m_endl << m_endl;
}
// write protected operations
if (forceSections() || !opprot.isEmpty()) {
cs << m_endl << m_container_indent << m_indentation << "#region Protected methods" << m_endl << m_endl;
writeOperations(opprot,cs,isInterface,false,generateErrorStub);
cs << m_container_indent << m_indentation << "#endregion" << m_endl << m_endl;
}
// write private operations
if (forceSections() || !oppriv.isEmpty()) {
cs << m_endl << m_container_indent << m_indentation << "#region Private methods" << m_endl << m_endl;
writeOperations(oppriv,cs,isInterface,false,generateErrorStub);
cs << m_container_indent << m_indentation << "#endregion" << m_endl << m_endl;
}
// write superclasses abstract methods
UMLClassifierList superclasses = c->getSuperClasses();
if (!isInterface && !c->getAbstract() && !c->hasAbstractOps()
&& superclasses.count() > 0) {
writeOverridesRecursive(&superclasses, cs);
}
}
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);
}
/**
* update the start and end text for this hierarchicalcodeblock.
*/
void CPPHeaderClassDeclarationBlock::updateContent ()
{
CPPHeaderCodeDocument *parentDoc = dynamic_cast<CPPHeaderCodeDocument*>(getParentDocument());
UMLClassifier *c = parentDoc->getParentClassifier();
QString endLine = UMLApp::app()->commonPolicy()->getNewLineEndingChars();
bool isInterface = parentDoc->parentIsInterface(); // a little shortcut
QString CPPHeaderClassName = CodeGenerator::cleanName(c->name());
bool forceDoc = UMLApp::app()->commonPolicy()->getCodeVerboseDocumentComments();
// COMMENT
//check if class is abstract.. it should have abstract methods
if(!isInterface && c->isAbstract() && !c->hasAbstractOps())
{
getComment()->setText(QLatin1String("******************************* Abstract Class ****************************") + endLine
+ CPPHeaderClassName + QLatin1String(" does not have any pure virtual methods, but its author") + endLine
+ QLatin1String(" defined it as an abstract class, so you should not use it directly.") + endLine
+ QLatin1String(" Inherit from it instead and create only objects from the derived classes") + endLine
+ QLatin1String("*****************************************************************************"));
} else {
if(isInterface)
getComment()->setText(QLatin1String("Interface ") + CPPHeaderClassName + endLine + c->doc());
else
getComment()->setText(QLatin1String("Class ") + CPPHeaderClassName + endLine + c->doc());
}
if(forceDoc || !c->doc().isEmpty())
getComment()->setWriteOutText(true);
else
getComment()->setWriteOutText(false);
// Now set START/ENDING Text
QString startText;
/*
*/
/*
if(parentDoc->parentIsInterface())
startText.append(QLatin1String("interface "));
else
*/
startText.append(QLatin1String("class "));
startText.append(CPPHeaderClassName);
// write inheritances out
UMLClassifierList superclasses = c->findSuperClassConcepts();
int nrof_superclasses = superclasses.count();
// write out inheritance
int i = 0;
if(nrof_superclasses >0)
startText.append(QLatin1String(" : "));
foreach (UMLClassifier* concept, superclasses) {
startText.append(Uml::Visibility::toString(concept->visibility()) + QLatin1Char(' ') +
CodeGenerator::cleanName(concept->name()));
if(i != (nrof_superclasses-1))
startText.append(QLatin1String(", "));
i++;
}
/**
* Call this method to generate C++ code for a UMLClassifier.
* @param c the class you want to generate code for.
*/
void RubyWriter::writeClass(UMLClassifier *c)
{
if (!c) {
uDebug() << "Cannot write class of NULL concept!";
return;
}
UMLClassifierList superclasses = c->getSuperClasses();
UMLAssociationList aggregations = c->getAggregations();
UMLAssociationList compositions = c->getCompositions();
//find an appropriate name for our file
fileName_ = findFileName(c, QLatin1String(".rb"));
if (fileName_.isEmpty()) {
emit codeGenerated(c, false);
return;
}
QFile fileh;
if (!openFile(fileh, fileName_)) {
emit codeGenerated(c, false);
return;
}
QTextStream h(&fileh);
className_ = cleanName(c->name());
//////////////////////////////
//Start generating the code!!
/////////////////////////////
//try to find a heading file (license, coments, etc)
QString str;
str = getHeadingFile(QLatin1String(".rb"));
if (!str.isEmpty()) {
str.replace(QRegExp(QLatin1String("%filename%")), fileName_);
str.replace(QRegExp(QLatin1String("%filepath%")), fileh.fileName());
h << str << m_endl;
}
if (forceDoc() || !c->doc().isEmpty()) {
QString docStr = c->doc();
docStr.replace(QRegExp(QLatin1String("\\n")), QLatin1String("\n# "));
docStr.remove(QLatin1String("@ref "));
docStr.replace(QLatin1String("@see"), QLatin1String("_See_"));
docStr.replace(QLatin1String("@short"), QLatin1String("_Summary_"));
docStr.replace(QLatin1String("@author"), QLatin1String("_Author_"));
h << "#" << m_endl;
h << "# " << docStr << m_endl;
h << "#" << m_endl << m_endl;
}
// write inheritances out
UMLClassifier *concept;
h << "class " << cppToRubyType(className_) << (superclasses.count() > 0 ? QLatin1String(" < ") : QString());
int i = 0;
foreach (concept, superclasses) {
if (i == 0) {
h << cppToRubyType(concept->name()) << m_endl;
} else {
// Assume ruby modules that can be mixed in, after the first
// superclass name in the list
h << m_indentation << "include " << cppToRubyType(concept->name()) << m_endl;
}
i++;
}
h << m_endl;
// write comment for sub-section IF needed
if (forceDoc() || c->hasAccessorMethods()) {
h << m_indentation << "#" << m_endl;
h << m_indentation << "# Accessor Methods" << m_endl;
h << m_indentation << "#" << m_endl << m_endl;
// Accessor methods for attributes
writeAttributeMethods(c->getAttributeList(Uml::Visibility::Public), Uml::Visibility::Public, h);
writeAttributeMethods(c->getAttributeList(Uml::Visibility::Protected), Uml::Visibility::Protected, h);
writeAttributeMethods(c->getAttributeList(Uml::Visibility::Private), Uml::Visibility::Private, h);
h << m_endl;
}
//operations
writeOperations(c, h);
//finish files
h << "end" << m_endl << m_endl;
//close files and notfiy we are done
fileh.close();
emit codeGenerated(c, true);
}
/**
* 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 XMLSchemaWriter::writeComplexTypeClassifierDecl (UMLClassifier *c,
UMLAssociationList associations,
UMLAssociationList aggregations,
UMLAssociationList compositions,
UMLClassifierList superclasses,
QTextStream &XMLschema)
{
// Preparations
//
// sort attributes by Scope
UMLAttributeList attribs = findAttributes(c);
QStringList attribGroups = findAttributeGroups(c);
// test for relevant associations
bool hasAssociations = determineIfHasChildNodes(c);
bool hasSuperclass = superclasses.count()> 0;
bool hasAttributes = attribs.count() > 0 || attribGroups.count() > 0;
// START WRITING
// start body of element
QString elementTypeName = getElementTypeName(c);
XMLschema<<getIndent()<<"<"<<makeSchemaTag("complexType")<<" name=\""<<elementTypeName<<"\"";
if(hasAssociations || hasAttributes || hasSuperclass)
{
XMLschema<<">"<<m_endl;
m_indentLevel++;
if(hasSuperclass)
{
QString superClassName = getElementTypeName(superclasses.first());
XMLschema<<getIndent()<<"<"<<makeSchemaTag("complexContent")<<">"<<m_endl;
//PROBLEM: we only treat ONE superclass for inheritence.. bah.
m_indentLevel++;
XMLschema<<getIndent()<<"<"<<makeSchemaTag("extension")<<" base=\""<<makePackageTag(superClassName)
<<"\"";
if(hasAssociations || hasAttributes )
XMLschema<<">"<<m_endl;
else
XMLschema<<"/>"<<m_endl;
m_indentLevel++;
}
if(hasAssociations)
{
// Child Elements (from most associations)
//
bool didFirstOne = false;
didFirstOne = writeAssociationDecls(associations, true, didFirstOne, c->getID(), XMLschema);
didFirstOne = writeAssociationDecls(aggregations, false, didFirstOne, c->getID(), XMLschema);
didFirstOne = writeAssociationDecls(compositions, false, didFirstOne, c->getID(), XMLschema);
if (didFirstOne) {
m_indentLevel--;
XMLschema<<getIndent()<<"</"<<makeSchemaTag("sequence")<<">"<<m_endl;
}
}
// ATTRIBUTES
//
if(hasAttributes)
{
writeAttributeDecls(attribs, XMLschema);
for(uint i= 0; i < attribGroups.count(); i++)
XMLschema<<getIndent()<<"<"<<makeSchemaTag("attributeGroup")<<" ref=\""
<<makePackageTag(attribGroups[i])<<"\"/>"<<m_endl;
}
if(hasSuperclass)
{
m_indentLevel--;
if(hasAssociations || hasAttributes )
XMLschema<<getIndent()<<"</"<<makeSchemaTag("extension")<<">"<<m_endl;
m_indentLevel--;
XMLschema<<getIndent()<<"</"<<makeSchemaTag("complexContent")<<">"<<m_endl;
}
// close this element decl
m_indentLevel--;
XMLschema<<getIndent()<<"</"<<makeSchemaTag("complexType")<<">"<<m_endl;
} else
XMLschema<<"/>"<<m_endl; // empty node. just close this element decl
}
