void CSharpWriter::writeAttributes(UMLClassifier *c, QTextStream &cs) {
UMLAttributeList atpub, atprot, atpriv, atdefval;
atpub.setAutoDelete(false);
atprot.setAutoDelete(false);
atpriv.setAutoDelete(false);
atdefval.setAutoDelete(false);
//sort attributes by scope and see if they have a default value
UMLAttributeList atl = c->getAttributeList();
UMLAttribute *at;
for (at = atl.first(); at ; at = atl.next()) {
if (!at->getInitialValue().isEmpty())
atdefval.append(at);
switch (at->getVisibility()) {
case Uml::Visibility::Public:
atpub.append(at);
break;
case Uml::Visibility::Protected:
atprot.append(at);
break;
case Uml::Visibility::Private:
atpriv.append(at);
break;
default:
break;
}
}
if (forceSections() || atl.count())
cs << m_endl << m_container_indent << m_indentation << "#region Attributes" << m_endl << m_endl;
// write public attributes
if (forceSections() || atpub.count()) {
writeAttributes(atpub,cs);
}
// write protected attributes
if (forceSections() || atprot.count()) {
writeAttributes(atprot,cs);
}
// write private attributes
if (forceSections() || atpriv.count()) {
writeAttributes(atpriv,cs);
}
if (forceSections() || atl.count())
cs << m_endl << m_container_indent << m_indentation << "#endregion" << m_endl << m_endl;
}
/**
* Write all operations for a given class.
* @param c the concept we are generating code for
* @param h output stream for the header file
*/
void RubyWriter::writeOperations(UMLClassifier *c, QTextStream &h)
{
//Lists to store operations sorted by scope
UMLOperationList oppub, opprot, oppriv;
//sort operations by scope first and see if there are abstract methods
UMLOperationList opl(c->getOpList());
foreach (UMLOperation *op, opl) {
switch(op->visibility()) {
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;
}
}
QString classname(cleanName(c->name()));
//write operations to file
if (forceSections() || !oppub.isEmpty()) {
writeOperations(classname, oppub, Uml::Visibility::Public, h);
}
if (forceSections() || !opprot.isEmpty()) {
writeOperations(classname, opprot, Uml::Visibility::Protected, h);
}
if (forceSections() || !oppriv.isEmpty()) {
writeOperations(classname, oppriv, Uml::Visibility::Private, h);
}
}
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);
}
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 SQLWriter::writeClass(UMLClassifier *c) {
if(!c) {
kDebug()<<"Cannot write class of NULL concept!" << endl;
return;
}
const bool isClass = !c->isInterface();
QString classname = cleanName(c->getName());
//find an appropriate name for our file
QString fileName = findFileName(c, ".sql");
if (fileName.isEmpty()) {
emit codeGenerated(c, false);
return;
}
QFile file;
if( !openFile(file, fileName) ) {
emit codeGenerated(c, false);
return;
}
//Start generating the code!!
QTextStream sql(&file);
//try to find a heading file (license, coments, etc)
QString str;
str = getHeadingFile(".sql");
if(!str.isEmpty()) {
str.replace(QRegExp("%filename%"),fileName);
str.replace(QRegExp("%filepath%"),file.name());
sql<<str<<m_endl;
}
//Write class Documentation if there is somthing or if force option
if(forceDoc() || !c->getDoc().isEmpty()) {
sql << m_endl << "--" << m_endl;
sql<<"-- TABLE: "<<classname<<m_endl;
sql<<formatDoc(c->getDoc(),"-- ");
sql << "-- " << m_endl << m_endl;
}
sql << "CREATE TABLE "<< classname << " ( " << m_endl;
if (isClass)
writeAttributes(c, sql);
sql << m_endl << ");" << m_endl;
QMap<UMLAssociation*,UMLAssociation*> constraintMap; // so we don't repeat constraint
UMLAssociationList aggregations = c->getAggregations();
if( forceSections() || !aggregations.isEmpty() ) {
for(UMLAssociation* a = aggregations.first(); a; a = aggregations.next()) {
UMLObject *objA = a->getObject(Uml::A);
UMLObject *objB = a->getObject(Uml::B);
if (objA->getID() == c->getID() && objB->getID() != c->getID())
continue;
constraintMap[a] = a;
}
}
QMap<UMLAssociation*,UMLAssociation*>::Iterator itor = constraintMap.begin();
for (;itor != constraintMap.end();itor++) {
UMLAssociation* a = itor.data();
sql << "ALTER TABLE "<< classname
<< " ADD CONSTRAINT " << a->getName() << " FOREIGN KEY ("
<< a->getRoleName(Uml::B) << ") REFERENCES "
<< a->getObject(Uml::A)->getName()
<< " (" << a->getRoleName(Uml::A) << ");" << m_endl;
}
file.close();
emit codeGenerated(c, true);
}
