codegenfactory.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "codegenfactory.h"
00020
00021
00022 #include <qstringlist.h>
00023 #include <kdebug.h>
00024
00025
00026 #include "../codegenerator.h"
00027 #include "../umldoc.h"
00028 #include "../uml.h"
00029 #include "../optionstate.h"
00030 #include "../operation.h"
00031 #include "../attribute.h"
00032 #include "../umlrole.h"
00033
00034 #include "adawriter.h"
00035 #include "cppwriter.h"
00036 #include "csharpwriter.h"
00037 #include "dwriter.h"
00038 #include "idlwriter.h"
00039 #include "javawriter.h"
00040 #include "pascalwriter.h"
00041 #include "perlwriter.h"
00042 #include "phpwriter.h"
00043 #include "php5writer.h"
00044 #include "pythonwriter.h"
00045 #include "rubywriter.h"
00046 #include "sqlwriter.h"
00047 #include "aswriter.h"
00048 #include "jswriter.h"
00049 #include "tclwriter.h"
00050 #include "xmlschemawriter.h"
00051
00052
00053 #include "cppcodegenerator.h"
00054 #include "javacodegenerator.h"
00055 #include "rubycodegenerator.h"
00056
00057 #include "cppheadercodedocument.h"
00058 #include "cppsourcecodedocument.h"
00059 #include "javaclassifiercodedocument.h"
00060 #include "rubyclassifiercodedocument.h"
00061 #include "javaantcodedocument.h"
00062
00063 #include "cppheadercodeoperation.h"
00064 #include "cppsourcecodeoperation.h"
00065 #include "javacodeoperation.h"
00066 #include "rubycodeoperation.h"
00067
00068 #include "cppcodeclassfield.h"
00069 #include "javacodeclassfield.h"
00070 #include "rubycodeclassfield.h"
00071
00072 #include "cppheadercodeaccessormethod.h"
00073 #include "cppsourcecodeaccessormethod.h"
00074 #include "javacodeaccessormethod.h"
00075 #include "rubycodeaccessormethod.h"
00076
00077 #include "cppheadercodeclassfielddeclarationblock.h"
00078 #include "cppsourcecodeclassfielddeclarationblock.h"
00079 #include "javacodeclassfielddeclarationblock.h"
00080 #include "rubycodeclassfielddeclarationblock.h"
00081
00082 #include "cppcodedocumentation.h"
00083 #include "javacodecomment.h"
00084 #include "rubycodecomment.h"
00085 #include "xmlcodecomment.h"
00086
00087 #include "cppcodegenerationpolicy.h"
00088 #include "javacodegenerationpolicy.h"
00089 #include "rubycodegenerationpolicy.h"
00090
00091 namespace CodeGenFactory {
00092
00093 CodeGenerator* createObject(Uml::Programming_Language pl) {
00094 CodeGenerator* obj = 0;
00095 Settings::OptionState optionState = Settings::getOptionState();
00096 UMLApp::app()->setPolicyExt(NULL);
00097 switch (pl) {
00098 case Uml::pl_Ada:
00099 obj = new AdaWriter();
00100 break;
00101 case Uml::pl_ActionScript:
00102 obj = new ASWriter();
00103 break;
00104 case Uml::pl_Cpp:
00105 if (optionState.generalState.newcodegen) {
00106 obj = new CPPCodeGenerator();
00107 obj->connect_newcodegen_slots();
00108 } else {
00109 obj = new CppWriter();
00110 }
00111 {
00112 CPPCodeGenerationPolicy *p =
00113 new CPPCodeGenerationPolicy(UMLApp::app()->getConfig());
00114 UMLApp::app()->setPolicyExt(p);
00115 }
00116 break;
00117 case Uml::pl_CSharp:
00118 obj = new CSharpWriter();
00119 break;
00120 case Uml::pl_D:
00121 obj = new DWriter();
00122 break;
00123 case Uml::pl_IDL:
00124 obj = new IDLWriter();
00125 break;
00126 case Uml::pl_Java:
00127 if (optionState.generalState.newcodegen) {
00128 obj = new JavaCodeGenerator();
00129 obj->connect_newcodegen_slots();
00130 JavaCodeGenerationPolicy *p =
00131 new JavaCodeGenerationPolicy(UMLApp::app()->getConfig());
00132 UMLApp::app()->setPolicyExt(p);
00133 } else
00134 obj = new JavaWriter();
00135 break;
00136 case Uml::pl_JavaScript:
00137 obj = new JSWriter();
00138 break;
00139 case Uml::pl_PHP:
00140 obj = new PhpWriter();
00141 break;
00142 case Uml::pl_PHP5:
00143 obj = new Php5Writer();
00144 break;
00145 case Uml::pl_Pascal:
00146 obj = new PascalWriter();
00147 break;
00148 case Uml::pl_Perl:
00149 obj = new PerlWriter();
00150 break;
00151 case Uml::pl_Python:
00152 obj = new PythonWriter();
00153 break;
00154 case Uml::pl_Ruby:
00155 if (optionState.generalState.newcodegen) {
00156 obj = new RubyCodeGenerator();
00157 obj->connect_newcodegen_slots();
00158 RubyCodeGenerationPolicy *p =
00159 new RubyCodeGenerationPolicy(UMLApp::app()->getConfig());
00160 UMLApp::app()->setPolicyExt(p);
00161 } else
00162 obj = new RubyWriter();
00163 break;
00164 case Uml::pl_SQL:
00165 obj = new SQLWriter();
00166 break;
00167 case Uml::pl_Tcl:
00168 obj = new TclWriter();
00169 break;
00170 case Uml::pl_XMLSchema:
00171 obj = new XMLSchemaWriter();
00172 break;
00173 default:
00174 kWarning() << "cannot create object of type " << pl
00175 << ". Type unknown" << endl;
00176 break;
00177 }
00178 if (obj)
00179 obj->initFromParentDocument();
00180 return obj;
00181 }
00182
00183 CodeDocument * newClassifierCodeDocument (UMLClassifier * c)
00184 {
00185 Settings::OptionState optionState = Settings::getOptionState();
00186 if (!optionState.generalState.newcodegen)
00187 return NULL;
00188 ClassifierCodeDocument *retval = NULL;
00189 switch (UMLApp::app()->getActiveLanguage()) {
00190 case Uml::pl_Cpp:
00191 retval = new CPPSourceCodeDocument(c);
00192 break;
00193 case Uml::pl_Java:
00194 retval = new JavaClassifierCodeDocument(c);
00195 break;
00196 case Uml::pl_Ruby:
00197 retval = new RubyClassifierCodeDocument(c);
00198 break;
00199 default:
00200 break;
00201 }
00202 retval->initCodeClassFields();
00203 retval->synchronize();
00204 return retval;
00205 }
00206
00207 CodeOperation *newCodeOperation(ClassifierCodeDocument *ccd, UMLOperation * op) {
00208 CodeOperation *retval = NULL;
00209 switch (UMLApp::app()->getActiveLanguage()) {
00210 case Uml::pl_Cpp:
00211 {
00212 CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(ccd);
00213 if (hcd)
00214 return new CPPHeaderCodeOperation(hcd, op);
00215 CPPSourceCodeDocument *scd = dynamic_cast<CPPSourceCodeDocument*>(ccd);
00216 if (scd)
00217 return new CPPSourceCodeOperation(scd, op);
00218 }
00219 break;
00220 case Uml::pl_Java:
00221 retval = new JavaCodeOperation(dynamic_cast<JavaClassifierCodeDocument*>(ccd), op);
00222 break;
00223 case Uml::pl_Ruby:
00224 retval = new RubyCodeOperation(dynamic_cast<RubyClassifierCodeDocument*>(ccd), op);
00225 break;
00226 default:
00227 break;
00228 }
00229 return retval;
00230 }
00231
00232
00233 CodeClassField * newCodeClassField(ClassifierCodeDocument *ccd, UMLAttribute *at) {
00234 CodeClassField *retval = NULL;
00235 switch (UMLApp::app()->getActiveLanguage()) {
00236 case Uml::pl_Cpp:
00237 retval = new CPPCodeClassField(ccd, at);
00238 break;
00239 case Uml::pl_Java:
00240 retval = new JavaCodeClassField(ccd, at);
00241 break;
00242 case Uml::pl_Ruby:
00243 retval = new RubyCodeClassField(ccd, at);
00244 break;
00245 default:
00246 break;
00247 }
00248 retval->finishInitialization();
00249 return retval;
00250 }
00251
00252 CodeClassField * newCodeClassField(ClassifierCodeDocument *ccd, UMLRole *role) {
00253 CodeClassField *retval = NULL;
00254 switch (UMLApp::app()->getActiveLanguage()) {
00255 case Uml::pl_Cpp:
00256 retval = new CPPCodeClassField(ccd, role);
00257 break;
00258 case Uml::pl_Java:
00259 retval = new JavaCodeClassField(ccd, role);
00260 break;
00261 case Uml::pl_Ruby:
00262 retval = new RubyCodeClassField(ccd, role);
00263 break;
00264 default:
00265 break;
00266 }
00267 return retval;
00268 }
00269
00270 CodeAccessorMethod * newCodeAccessorMethod(ClassifierCodeDocument *ccd,
00271 CodeClassField *cf,
00272 CodeAccessorMethod::AccessorType type) {
00273 CodeAccessorMethod *retval = NULL;
00274 switch (UMLApp::app()->getActiveLanguage()) {
00275 case Uml::pl_Cpp:
00276 {
00277 CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(ccd);
00278 if (hcd) {
00279 CPPHeaderCodeAccessorMethod *chcam = new CPPHeaderCodeAccessorMethod(cf, type);
00280 chcam->update();
00281 retval = chcam;
00282 } else {
00283 CPPSourceCodeAccessorMethod *cscam = new CPPSourceCodeAccessorMethod(cf, type);
00284 cscam->update();
00285 retval = cscam;
00286 }
00287 }
00288 break;
00289 case Uml::pl_Java:
00290 {
00291 JavaCodeAccessorMethod *jcam = new JavaCodeAccessorMethod(cf, type);
00292 jcam->update();
00293 retval = jcam;
00294 retval->setOverallIndentationLevel(1);
00295 }
00296 break;
00297 case Uml::pl_Ruby:
00298 {
00299 RubyCodeAccessorMethod *rcam = new RubyCodeAccessorMethod(cf, type);
00300 rcam->update();
00301 retval = rcam;
00302 retval->setOverallIndentationLevel(1);
00303 }
00304 break;
00305 default:
00306 break;
00307 }
00308 return retval;
00309 }
00310
00311 CodeClassFieldDeclarationBlock * newDeclarationCodeBlock (ClassifierCodeDocument *cd,
00312 CodeClassField * cf) {
00313 CodeClassFieldDeclarationBlock *retval = NULL;
00314 switch (UMLApp::app()->getActiveLanguage()) {
00315 case Uml::pl_Cpp:
00316 {
00317 CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(cd);
00318 if (hcd)
00319 return new CPPHeaderCodeClassFieldDeclarationBlock(cf);
00320 CPPSourceCodeDocument *scd = dynamic_cast<CPPSourceCodeDocument*>(cd);
00321 if (scd)
00322 return new CPPSourceCodeClassFieldDeclarationBlock(cf);
00323 }
00324 break;
00325 case Uml::pl_Java:
00326 retval = new JavaCodeClassFieldDeclarationBlock(cf);
00327 break;
00328 case Uml::pl_Ruby:
00329 retval = new RubyCodeClassFieldDeclarationBlock(cf);
00330 break;
00331 default:
00332 break;
00333 }
00334 return retval;
00335 }
00336
00337 CodeComment * newCodeComment (CodeDocument *cd) {
00338 switch (UMLApp::app()->getActiveLanguage()) {
00339 case Uml::pl_Cpp:
00340 if (dynamic_cast<CPPHeaderCodeDocument*>(cd) ||
00341 dynamic_cast<CPPSourceCodeDocument*>(cd))
00342 return new CPPCodeDocumentation(cd);
00343 break;
00344 case Uml::pl_Java:
00345 if (dynamic_cast<JavaClassifierCodeDocument*>(cd))
00346 return new JavaCodeComment(cd);
00347 break;
00348 case Uml::pl_Ruby:
00349 if (dynamic_cast<RubyClassifierCodeDocument*>(cd))
00350 return new RubyCodeComment(cd);
00351 break;
00352 default:
00353 break;
00354 }
00355 if (dynamic_cast<JavaANTCodeDocument*>(cd))
00356 return new XMLCodeComment(cd);
00357 return new CodeComment(cd);
00358 }
00359
00360 }
00361
