• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdesdk API Reference
  • KDE Home
  • Contact Us
 

umbrello/umbrello

  • sources
  • kde-4.12
  • kdesdk
  • umbrello
  • umbrello
  • codegenerators
codegenfactory.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * This program is free software; you can redistribute it and/or modify *
3  * it under the terms of the GNU General Public License as published by *
4  * the Free Software Foundation; either version 2 of the License, or *
5  * (at your option) any later version. *
6  * *
7  * copyright (C) 2002 Luis De la Parra Blum <luis@delaparra.org> *
8  Brian Thomas <thomas@mail630.gsfc.nasa.gov> *
9  * copyright (C) 2003-2013 *
10  * Umbrello UML Modeller Authors <umbrello-devel@kde.org> *
11  ***************************************************************************/
12 
13 // own header
14 #include "codegenfactory.h"
15 
16 // app includes
17 #include "attribute.h"
18 #include "codegenerator.h"
19 #include "debug_utils.h"
20 #include "optionstate.h"
21 #include "operation.h"
22 #include "uml.h"
23 #include "umldoc.h"
24 #include "umlrole.h"
25 
26 #include "adawriter.h"
27 #include "cppwriter.h"
28 #include "csharpwriter.h"
29 #include "dwriter.h"
30 #include "idlwriter.h"
31 #include "javawriter.h"
32 #include "mysqlwriter.h"
33 #include "pascalwriter.h"
34 #include "perlwriter.h"
35 #include "phpwriter.h"
36 #include "php5writer.h"
37 #include "postgresqlwriter.h"
38 #include "pythonwriter.h"
39 #include "rubywriter.h"
40 #include "sqlwriter.h"
41 #include "aswriter.h"
42 #include "jswriter.h"
43 #include "tclwriter.h"
44 #include "valawriter.h"
45 #include "xmlschemawriter.h"
46 
47 // the new
48 #include "cppcodegenerator.h"
49 #include "dcodegenerator.h"
50 #include "javacodegenerator.h"
51 #include "rubycodegenerator.h"
52 
53 #include "cppheadercodedocument.h"
54 #include "cppsourcecodedocument.h"
55 #include "dclassifiercodedocument.h"
56 #include "javaclassifiercodedocument.h"
57 #include "rubyclassifiercodedocument.h"
58 #include "javaantcodedocument.h"
59 
60 #include "cppheadercodeoperation.h"
61 #include "cppsourcecodeoperation.h"
62 #include "dcodeoperation.h"
63 #include "javacodeoperation.h"
64 #include "rubycodeoperation.h"
65 
66 #include "cppcodeclassfield.h"
67 #include "dcodeclassfield.h"
68 #include "javacodeclassfield.h"
69 #include "rubycodeclassfield.h"
70 
71 #include "cppheadercodeaccessormethod.h"
72 #include "cppsourcecodeaccessormethod.h"
73 #include "dcodeaccessormethod.h"
74 #include "javacodeaccessormethod.h"
75 #include "rubycodeaccessormethod.h"
76 
77 #include "cppheadercodeclassfielddeclarationblock.h"
78 #include "cppsourcecodeclassfielddeclarationblock.h"
79 #include "dcodeclassfielddeclarationblock.h"
80 #include "javacodeclassfielddeclarationblock.h"
81 #include "rubycodeclassfielddeclarationblock.h"
82 
83 #include "cppcodedocumentation.h"
84 #include "dcodecomment.h"
85 #include "javacodecomment.h"
86 #include "rubycodecomment.h"
87 #include "xmlcodecomment.h"
88 
89 #include "cppcodegenerationpolicy.h"
90 #include "dcodegenerationpolicy.h"
91 #include "javacodegenerationpolicy.h"
92 #include "rubycodegenerationpolicy.h"
93 
94 namespace CodeGenFactory
95 {
96 
97 CodeGenerator* createObject(Uml::ProgrammingLanguage::Enum pl)
98 {
99  CodeGenerator* obj = 0;
100  Settings::OptionState optionState = Settings::optionState();
101  switch (pl) {
102  case Uml::ProgrammingLanguage::Ada:
103  obj = new AdaWriter();
104  break;
105  case Uml::ProgrammingLanguage::ActionScript:
106  obj = new ASWriter();
107  break;
108  case Uml::ProgrammingLanguage::Cpp:
109  if (optionState.generalState.newcodegen) {
110  obj = new CPPCodeGenerator();
111  obj->connect_newcodegen_slots();
112  } else {
113  obj = new CppWriter();
114  }
115  break;
116  case Uml::ProgrammingLanguage::CSharp:
117  obj = new CSharpWriter();
118  break;
119  case Uml::ProgrammingLanguage::D:
120  if (optionState.generalState.newcodegen) {
121  obj = new DCodeGenerator();
122  obj->connect_newcodegen_slots();
123  } else {
124  obj = new DWriter();
125  }
126  break;
127  case Uml::ProgrammingLanguage::IDL:
128  obj = new IDLWriter();
129  break;
130  case Uml::ProgrammingLanguage::Java:
131  if (optionState.generalState.newcodegen) {
132  obj = new JavaCodeGenerator();
133  obj->connect_newcodegen_slots();
134  } else {
135  obj = new JavaWriter();
136  }
137  break;
138  case Uml::ProgrammingLanguage::JavaScript:
139  obj = new JSWriter();
140  break;
141  case Uml::ProgrammingLanguage::MySQL:
142  obj = new MySQLWriter();
143  break;
144  case Uml::ProgrammingLanguage::PHP:
145  obj = new PhpWriter();
146  break;
147  case Uml::ProgrammingLanguage::PHP5:
148  obj = new Php5Writer();
149  break;
150  case Uml::ProgrammingLanguage::Pascal:
151  obj = new PascalWriter();
152  break;
153  case Uml::ProgrammingLanguage::Perl:
154  obj = new PerlWriter();
155  break;
156  case Uml::ProgrammingLanguage::PostgreSQL:
157  obj = new PostgreSQLWriter();
158  break;
159  case Uml::ProgrammingLanguage::Python:
160  obj = new PythonWriter();
161  break;
162  case Uml::ProgrammingLanguage::Ruby:
163  if (optionState.generalState.newcodegen) {
164  obj = new RubyCodeGenerator();
165  obj->connect_newcodegen_slots();
166  } else {
167  obj = new RubyWriter();
168  }
169  break;
170  case Uml::ProgrammingLanguage::SQL:
171  obj = new SQLWriter();
172  break;
173  case Uml::ProgrammingLanguage::Tcl:
174  obj = new TclWriter();
175  break;
176  case Uml::ProgrammingLanguage::Vala:
177  obj = new ValaWriter();
178  break;
179  case Uml::ProgrammingLanguage::XMLSchema:
180  obj = new XMLSchemaWriter();
181  break;
182  default:
183  uWarning() << "cannot create object of type "
184  << Uml::ProgrammingLanguage::toString(pl)
185  << ". Type unknown";
186  break;
187  }
188 
189  UMLApp::app()->setPolicyExt(CodeGenFactory::newCodeGenPolicyExt(pl));
190  if (obj) {
191  obj->initFromParentDocument();
192  }
193  return obj;
194 }
195 
196 CodeDocument * newClassifierCodeDocument(UMLClassifier * c)
197 {
198  Settings::OptionState optionState = Settings::optionState();
199  if (!optionState.generalState.newcodegen) {
200  return NULL;
201  }
202  ClassifierCodeDocument *retval = NULL;
203  switch (UMLApp::app()->activeLanguage()) {
204  case Uml::ProgrammingLanguage::Cpp:
205  retval = new CPPSourceCodeDocument(c);
206  break;
207  case Uml::ProgrammingLanguage::D:
208  retval = new DClassifierCodeDocument(c);
209  break;
210  case Uml::ProgrammingLanguage::Java:
211  retval = new JavaClassifierCodeDocument(c);
212  break;
213  case Uml::ProgrammingLanguage::Ruby:
214  retval = new RubyClassifierCodeDocument(c);
215  break;
216  default:
217  break;
218  }
219  retval->initCodeClassFields();
220  retval->synchronize();
221  return retval;
222 }
223 
224 CodeOperation *newCodeOperation(ClassifierCodeDocument *ccd, UMLOperation * op)
225 {
226  CodeOperation *retval = NULL;
227  switch (UMLApp::app()->activeLanguage()) {
228  case Uml::ProgrammingLanguage::Cpp:
229  {
230  CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(ccd);
231  if (hcd) {
232  CPPHeaderCodeOperation *cpphcd = new CPPHeaderCodeOperation(hcd, op);
233  cpphcd->updateMethodDeclaration();
234  cpphcd->updateContent();
235  return cpphcd;
236  }
237  CPPSourceCodeDocument *scd = dynamic_cast<CPPSourceCodeDocument*>(ccd);
238  if (scd) {
239  CPPSourceCodeOperation *cppscd = new CPPSourceCodeOperation(scd, op);
240  cppscd->updateMethodDeclaration();
241  cppscd->updateContent();
242  return cppscd;
243  }
244  }
245  break;
246  case Uml::ProgrammingLanguage::D:
247  retval = new DCodeOperation(dynamic_cast<DClassifierCodeDocument*>(ccd), op);
248  retval->updateMethodDeclaration();
249  retval->updateContent();
250  break;
251  case Uml::ProgrammingLanguage::Java:
252  retval = new JavaCodeOperation(dynamic_cast<JavaClassifierCodeDocument*>(ccd), op);
253  retval->updateMethodDeclaration();
254  retval->updateContent();
255  break;
256  case Uml::ProgrammingLanguage::Ruby:
257  retval = new RubyCodeOperation(dynamic_cast<RubyClassifierCodeDocument*>(ccd), op);
258  retval->updateMethodDeclaration();
259  retval->updateContent();
260  break;
261  default:
262  break;
263  }
264  return retval;
265 }
266 
267 CodeClassField * newCodeClassField(ClassifierCodeDocument *ccd, UMLAttribute *at)
268 {
269  CodeClassField *retval = NULL;
270  switch (UMLApp::app()->activeLanguage()) {
271  case Uml::ProgrammingLanguage::Cpp:
272  retval = new CPPCodeClassField(ccd, at);
273  break;
274  case Uml::ProgrammingLanguage::D:
275  retval = new DCodeClassField(ccd, at);
276  break;
277  case Uml::ProgrammingLanguage::Java:
278  retval = new JavaCodeClassField(ccd, at);
279  break;
280  case Uml::ProgrammingLanguage::Ruby:
281  retval = new RubyCodeClassField(ccd, at);
282  break;
283  default:
284  break;
285  }
286  retval->finishInitialization();
287  return retval;
288 }
289 
290 CodeClassField * newCodeClassField(ClassifierCodeDocument *ccd, UMLRole *role)
291 {
292  CodeClassField *retval = NULL;
293  switch (UMLApp::app()->activeLanguage()) {
294  case Uml::ProgrammingLanguage::Cpp:
295  retval = new CPPCodeClassField(ccd, role);
296  break;
297  case Uml::ProgrammingLanguage::D:
298  retval = new DCodeClassField(ccd, role);
299  break;
300  case Uml::ProgrammingLanguage::Java:
301  retval = new JavaCodeClassField(ccd, role);
302  break;
303  case Uml::ProgrammingLanguage::Ruby:
304  retval = new RubyCodeClassField(ccd, role);
305  break;
306  default:
307  break;
308  }
309  retval->finishInitialization();
310  return retval;
311 }
312 
313 CodeAccessorMethod * newCodeAccessorMethod(ClassifierCodeDocument *ccd,
314  CodeClassField *cf,
315  CodeAccessorMethod::AccessorType type)
316 {
317  CodeAccessorMethod *retval = NULL;
318  switch (UMLApp::app()->activeLanguage()) {
319  case Uml::ProgrammingLanguage::Cpp:
320  {
321  CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(ccd);
322  if (hcd) {
323  CPPHeaderCodeAccessorMethod *chcam = new CPPHeaderCodeAccessorMethod(cf, type);
324  chcam->update();
325  retval = chcam;
326  } else {
327  CPPSourceCodeAccessorMethod *cscam = new CPPSourceCodeAccessorMethod(cf, type);
328  cscam->update();
329  retval = cscam;
330  }
331  }
332  break;
333  case Uml::ProgrammingLanguage::D:
334  {
335  DCodeAccessorMethod *jcam = new DCodeAccessorMethod(cf, type);
336  jcam->update();
337  retval = jcam;
338  retval->setOverallIndentationLevel(1);
339  }
340  break;
341  case Uml::ProgrammingLanguage::Java:
342  {
343  JavaCodeAccessorMethod *jcam = new JavaCodeAccessorMethod(cf, type);
344  jcam->update();
345  retval = jcam;
346  retval->setOverallIndentationLevel(1);
347  }
348  break;
349  case Uml::ProgrammingLanguage::Ruby:
350  {
351  RubyCodeAccessorMethod *rcam = new RubyCodeAccessorMethod(cf, type);
352  rcam->update();
353  retval = rcam;
354  retval->setOverallIndentationLevel(1);
355  }
356  break;
357  default:
358  break;
359  }
360  return retval;
361 }
362 
363 CodeClassFieldDeclarationBlock * newDeclarationCodeBlock(ClassifierCodeDocument *cd,
364  CodeClassField * cf)
365 {
366  CodeClassFieldDeclarationBlock *retval = NULL;
367  switch (UMLApp::app()->activeLanguage()) {
368  case Uml::ProgrammingLanguage::Cpp:
369  {
370  CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(cd);
371  if (hcd) {
372  CPPHeaderCodeClassFieldDeclarationBlock * cpphcd = new CPPHeaderCodeClassFieldDeclarationBlock(cf);
373  cpphcd->updateContent();
374  return cpphcd;
375  }
376  CPPSourceCodeDocument *scd = dynamic_cast<CPPSourceCodeDocument*>(cd);
377  if (scd) {
378  CPPSourceCodeClassFieldDeclarationBlock *cppscd = new CPPSourceCodeClassFieldDeclarationBlock(cf);
379  cppscd->updateContent();
380  return cppscd;
381  }
382  }
383  break;
384  case Uml::ProgrammingLanguage::D:
385  retval = new DCodeClassFieldDeclarationBlock(cf);
386  retval->updateContent();
387  break;
388  case Uml::ProgrammingLanguage::Java:
389  retval = new JavaCodeClassFieldDeclarationBlock(cf);
390  retval->updateContent();
391  break;
392  case Uml::ProgrammingLanguage::Ruby:
393  retval = new RubyCodeClassFieldDeclarationBlock(cf);
394  retval->updateContent();
395  break;
396  default:
397  break;
398  }
399  return retval;
400 }
401 
402 CodeComment * newCodeComment(CodeDocument *cd)
403 {
404  switch (UMLApp::app()->activeLanguage()) {
405  case Uml::ProgrammingLanguage::Cpp:
406  if (dynamic_cast<CPPHeaderCodeDocument*>(cd) ||
407  dynamic_cast<CPPSourceCodeDocument*>(cd)) {
408  return new CPPCodeDocumentation(cd);
409  }
410  break;
411  case Uml::ProgrammingLanguage::D:
412  if (dynamic_cast<DClassifierCodeDocument*>(cd)) {
413  return new DCodeComment(cd);
414  }
415  break;
416  case Uml::ProgrammingLanguage::Java:
417  if (dynamic_cast<JavaClassifierCodeDocument*>(cd)) {
418  return new JavaCodeComment(cd);
419  }
420  break;
421  case Uml::ProgrammingLanguage::Ruby:
422  if (dynamic_cast<RubyClassifierCodeDocument*>(cd)) {
423  return new RubyCodeComment(cd);
424  }
425  break;
426  default:
427  break;
428  }
429  if (dynamic_cast<JavaANTCodeDocument*>(cd)) {
430  return new XMLCodeComment(cd);
431  }
432  return new CodeComment(cd);
433 }
434 
435 CodeGenPolicyExt* newCodeGenPolicyExt(Uml::ProgrammingLanguage::Enum pl)
436 {
437  Settings::OptionState optionState = Settings::optionState();
438 
439  if (pl == Uml::ProgrammingLanguage::Cpp) {
440  return new CPPCodeGenerationPolicy();
441  }
442 
443  if (optionState.generalState.newcodegen) {
444  switch(pl) {
445  case Uml::ProgrammingLanguage::Java:
446  return new JavaCodeGenerationPolicy();
447  break;
448  case Uml::ProgrammingLanguage::D:
449  return new DCodeGenerationPolicy();
450  break;
451  case Uml::ProgrammingLanguage::Ruby:
452  return new RubyCodeGenerationPolicy();
453  break;
454  default:
455  return NULL;
456  }
457  }
458 
459  return NULL;
460 }
461 
462 } // end namespace CodeGenFactory
ASWriter
Class ASWriter is a ActionScript code generator for UMLClassifier objects.
Definition: aswriter.h:25
RubyCodeClassFieldDeclarationBlock
Definition: rubycodeclassfielddeclarationblock.h:20
Uml::ProgrammingLanguage::XMLSchema
Definition: basictypes.h:261
dcodecomment.h
csharpwriter.h
Uml::ProgrammingLanguage::Ruby
Definition: basictypes.h:257
UMLApp::setPolicyExt
void setPolicyExt(CodeGenPolicyExt *policy)
Sets the CodeGenPolicyExt object.
Definition: uml.cpp:2140
XMLCodeComment
class XMLCodeDocumentation A XML (code) comment.
Definition: xmlcodecomment.h:25
CodeClassField
class CodeClassField a special type of parameter.
Definition: codeclassfield.h:29
UMLClassifier
This class defines the non-graphical information required for a UML Classifier (ie a class or interfa...
Definition: classifier.h:39
ClassifierCodeDocument::initCodeClassFields
virtual void initCodeClassFields()
Add codeclassfields to this classifiercodedocument.
Definition: classifiercodedocument.cpp:535
XMLSchemaWriter
Class XMLSchemaWriter is a code generator for UMLClassifier objects.
Definition: xmlschemawriter.h:37
DCodeGenerator
Definition: dcodegenerator.h:26
IDLWriter
Class IDLWriter is a code generator for UMLClassifier objects.
Definition: idlwriter.h:29
CodeGenFactory::newDeclarationCodeBlock
CodeClassFieldDeclarationBlock * newDeclarationCodeBlock(ClassifierCodeDocument *cd, CodeClassField *cf)
Definition: codegenfactory.cpp:363
JavaClassifierCodeDocument
class JavaClassifierCodeDocument A Java UMLClassifier Code Document.
Definition: javaclassifiercodedocument.h:32
dcodeclassfield.h
Uml::ProgrammingLanguage::IDL
Definition: basictypes.h:247
cppcodeclassfield.h
CSharpWriter
Class CSharpWriter is a C# code generator for UMLClassifier objects Just call writeClass and feed it ...
Definition: csharpwriter.h:25
Uml::ProgrammingLanguage::Ada
Definition: basictypes.h:243
Settings::optionState
OptionState & optionState()
Definition: optionstate.cpp:25
ClassifierCodeDocument
class ClassifierCodeDocument A CodeDocument which represents a UMLClassifier (e.g.
Definition: classifiercodedocument.h:33
CPPSourceCodeOperation
Definition: cppsourcecodeoperation.h:21
CodeGenFactory::newClassifierCodeDocument
CodeDocument * newClassifierCodeDocument(UMLClassifier *c)
Definition: codegenfactory.cpp:196
CPPHeaderCodeAccessorMethod
Definition: cppheadercodeaccessormethod.h:21
Settings::OptionState::generalState
GeneralState generalState
Definition: optionstate.h:142
DCodeAccessorMethod::update
void update()
Must be called before this object is usable.
Definition: dcodeaccessormethod.cpp:200
CPPHeaderCodeDocument
class CPPHeaderCodeDocument A CPP UMLClassifier Header Code Document.
Definition: cppheadercodedocument.h:35
SQLWriter
Class SQLWriter is a code generator for UMLClassifier objects.
Definition: sqlwriter.h:29
sqlwriter.h
umlrole.h
Uml::ProgrammingLanguage::Cpp
Definition: basictypes.h:244
rubycodegenerationpolicy.h
JavaCodeAccessorMethod
Definition: javacodeaccessormethod.h:21
JSWriter
Class JSWriter is a JavaScript code generator for UMLClassifier objects.
Definition: jswriter.h:25
CPPHeaderCodeOperation::updateMethodDeclaration
virtual void updateMethodDeclaration()
This is the method called from within syncToparent().
Definition: cppheadercodeoperation.cpp:55
CodeAccessorMethod::AccessorType
AccessorType
Definition: codeaccessormethod.h:32
jswriter.h
Uml::ProgrammingLanguage::Enum
Enum
Definition: basictypes.h:241
PerlWriter
Class PerlWriter is a Perl code generator for UMLClassifier objects.
Definition: perlwriter.h:27
rubycodecomment.h
UMLApp::app
static UMLApp * app()
Get the last created instance of this class.
Definition: uml.cpp:206
cppsourcecodeoperation.h
CodeBlockWithComments::setOverallIndentationLevel
void setOverallIndentationLevel(int level)
A utility method that causes the comment and body of the code block to have the same indentation leve...
Definition: codeblockwithcomments.cpp:163
CodeOperation::updateMethodDeclaration
virtual void updateMethodDeclaration()=0
This is the method called from within syncToparent().
CodeGenFactory::newCodeGenPolicyExt
CodeGenPolicyExt * newCodeGenPolicyExt(Uml::ProgrammingLanguage::Enum pl)
Definition: codegenfactory.cpp:435
UMLAttribute
This class is used to set up information for an attribute.
Definition: attribute.h:27
cppsourcecodeaccessormethod.h
adawriter.h
CPPSourceCodeOperation::updateContent
virtual void updateContent()
Just want to know whether or not to print out the body of the operation.
Definition: cppsourcecodeoperation.cpp:36
perlwriter.h
Uml::ProgrammingLanguage::Tcl
Definition: basictypes.h:259
CppWriter
Class CppWriter is a code generator for UMLClassifier objects.
Definition: cppwriter.h:34
CodeOperation::updateContent
virtual void updateContent()
This is the method called from within syncToparent() to update the body of the method.
Definition: codeoperation.cpp:151
uWarning
#define uWarning()
Definition: debug_utils.h:97
CodeClassFieldDeclarationBlock
Used to declare classifier fields (e.g.
Definition: codeclassfielddeclarationblock.h:29
JavaCodeAccessorMethod::update
void update()
Must be called before this object is usable.
Definition: javacodeaccessormethod.cpp:198
CPPHeaderCodeClassFieldDeclarationBlock
Definition: cppheadercodeclassfielddeclarationblock.h:19
php5writer.h
CPPSourceCodeClassFieldDeclarationBlock::updateContent
void updateContent()
This will be called by syncToParent whenever the parent object is "modified".
Definition: cppsourcecodeclassfielddeclarationblock.cpp:27
debug_utils.h
CodeGenerator::connect_newcodegen_slots
void connect_newcodegen_slots()
Connect additional slots.
Definition: codegenerator.cpp:821
RubyCodeOperation
Definition: rubycodeoperation.h:22
rubycodeclassfielddeclarationblock.h
tclwriter.h
dwriter.h
cppheadercodeoperation.h
Settings::OptionState
Definition: optionstate.h:141
javacodeclassfield.h
CodeGenFactory::newCodeClassField
CodeClassField * newCodeClassField(ClassifierCodeDocument *ccd, UMLAttribute *at)
Definition: codegenfactory.cpp:267
pascalwriter.h
Uml::ProgrammingLanguage::D
Definition: basictypes.h:246
dcodeoperation.h
DWriter
Class DWriter is a code generator for UMLClassifier objects.
Definition: dwriter.h:32
Uml::ProgrammingLanguage::Vala
Definition: basictypes.h:260
cppsourcecodedocument.h
Uml::ProgrammingLanguage::CSharp
Definition: basictypes.h:245
PhpWriter
Class PhpWriter is a PHP code generator for UMLClassifier objects.
Definition: phpwriter.h:23
codegenerator.h
javaclassifiercodedocument.h
valawriter.h
JavaCodeClassFieldDeclarationBlock
Definition: javacodeclassfielddeclarationblock.h:19
JavaCodeGenerationPolicy
Definition: javacodegenerationpolicy.h:23
Uml::ProgrammingLanguage::PostgreSQL
Definition: basictypes.h:255
Php5Writer
Class Php5Writer is a PHP code generator for UMLClassifier objects.
Definition: php5writer.h:24
aswriter.h
attribute.h
optionstate.h
javacodegenerationpolicy.h
codegenfactory.h
Uml::ProgrammingLanguage::ActionScript
Definition: basictypes.h:242
CodeGenFactory::newCodeAccessorMethod
CodeAccessorMethod * newCodeAccessorMethod(ClassifierCodeDocument *ccd, CodeClassField *cf, CodeAccessorMethod::AccessorType type)
Definition: codegenfactory.cpp:313
CodeOperation
Definition: codeoperation.h:23
javaantcodedocument.h
Uml::ProgrammingLanguage::SQL
Definition: basictypes.h:258
RubyClassifierCodeDocument
class RubyClassifierCodeDocument A Ruby UMLClassifier Code Document.
Definition: rubyclassifiercodedocument.h:36
JavaCodeOperation
Definition: javacodeoperation.h:21
DClassifierCodeDocument
A D UMLClassifier Code Document.
Definition: dclassifiercodedocument.h:36
Uml::ProgrammingLanguage::toString
QString toString(Enum item)
Return string corresponding to the given ProgrammingLanguage.
Definition: basictypes.cpp:801
CPPSourceCodeClassFieldDeclarationBlock
Definition: cppsourcecodeclassfielddeclarationblock.h:19
pythonwriter.h
cppcodegenerator.h
CodeDocument
A document containing the code for one file.
Definition: codedocument.h:32
CPPCodeGenerator
Definition: cppcodegenerator.h:26
Settings::GeneralState::newcodegen
bool newcodegen
Definition: optionstate.h:37
Uml::ProgrammingLanguage::Java
Definition: basictypes.h:248
javacodeaccessormethod.h
rubycodeaccessormethod.h
xmlcodecomment.h
RubyCodeGenerator
Definition: rubycodegenerator.h:27
cppcodegenerationpolicy.h
javawriter.h
CPPHeaderCodeOperation::updateContent
virtual void updateContent()
This is the method called from within syncToparent() to update the body of the method.
Definition: cppheadercodeoperation.cpp:44
CPPSourceCodeDocument
A CPP UMLClassifier Source Code Document.
Definition: cppsourcecodedocument.h:22
CodeGenFactory::newCodeComment
CodeComment * newCodeComment(CodeDocument *cd)
Definition: codegenfactory.cpp:402
RubyCodeGenerationPolicy
Definition: rubycodegenerationpolicy.h:24
CPPCodeClassField
Definition: cppcodeclassfield.h:21
Uml::ProgrammingLanguage::Perl
Definition: basictypes.h:252
JavaWriter
Class JavaWriter is a code generator for UMLClassifier objects.
Definition: javawriter.h:32
CodeAccessorMethod
Definition: codeaccessormethod.h:20
rubywriter.h
DCodeClassFieldDeclarationBlock
Definition: dcodeclassfielddeclarationblock.h:19
rubycodeoperation.h
CPPCodeDocumentation
class CPPCodeDocumentation A CPP code comment.
Definition: cppcodedocumentation.h:27
PascalWriter
Pascal class writer.
Definition: pascalwriter.h:25
DCodeAccessorMethod
Definition: dcodeaccessormethod.h:21
Uml::ProgrammingLanguage::Python
Definition: basictypes.h:256
CodeClassFieldDeclarationBlock::updateContent
virtual void updateContent()=0
CodeGenFactory::createObject
CodeGenerator * createObject(Uml::ProgrammingLanguage::Enum pl)
Definition: codegenfactory.cpp:97
AdaWriter
Class AdaWriter is a code generator for UMLClassifier objects.
Definition: adawriter.h:28
phpwriter.h
mysqlwriter.h
CPPHeaderCodeAccessorMethod::update
void update()
Must be called before this object is usable.
Definition: cppheadercodeaccessormethod.cpp:33
cppcodedocumentation.h
cppsourcecodeclassfielddeclarationblock.h
CPPCodeGenerationPolicy
Definition: cppcodegenerationpolicy.h:23
Uml::ProgrammingLanguage::MySQL
Definition: basictypes.h:250
Uml::ProgrammingLanguage::PHP5
Definition: basictypes.h:254
javacodegenerator.h
operation.h
DCodeGenerationPolicy
Definition: dcodegenerationpolicy.h:23
umldoc.h
PythonWriter
Class PythonWriter is a python code generator for UMLClassifier objects Just call writeClass and feed...
Definition: pythonwriter.h:26
dclassifiercodedocument.h
UMLOperation
This class represents an operation in the UML model.
Definition: operation.h:24
rubycodeclassfield.h
dcodegenerator.h
ValaWriter
Class ValaWriter is a Vala code generator for UMLClassifier objects Just call writeClass and feed it ...
Definition: valawriter.h:28
rubyclassifiercodedocument.h
UMLRole
This class contains the non-graphic representation of an association role.
Definition: umlrole.h:24
JavaCodeClassField
Definition: javacodeclassfield.h:21
DCodeOperation
Definition: dcodeoperation.h:21
PostgreSQLWriter
class PostgreSQLWriter is a sql code generator for PostgreSQL Create an instance of this class...
Definition: postgresqlwriter.h:22
Uml::ProgrammingLanguage::Pascal
Definition: basictypes.h:251
javacodecomment.h
CodeGenerator
This class collects together all of the code documents which form this project, and generates code fo...
Definition: codegenerator.h:68
JavaCodeGenerator
Definition: javacodegenerator.h:27
javacodeoperation.h
RubyCodeAccessorMethod::update
void update()
Must be called before this object is usable.
Definition: rubycodeaccessormethod.cpp:225
cppheadercodedocument.h
CPPHeaderCodeClassFieldDeclarationBlock::updateContent
void updateContent()
This will be called by syncToParent whenever the parent object is "modified".
Definition: cppheadercodeclassfielddeclarationblock.cpp:28
dcodegenerationpolicy.h
xmlschemawriter.h
JavaCodeComment
class JavaCodeComment A Java code comment.
Definition: javacodecomment.h:25
cppheadercodeclassfielddeclarationblock.h
RubyWriter
Class RubyWriter is a ruby code generator for UMLClassifier objects.
Definition: rubywriter.h:26
CPPHeaderCodeOperation
Definition: cppheadercodeoperation.h:21
CodeGenPolicyExt
Base class for programming language specific code generation policy extensions.
Definition: codegenpolicyext.h:28
RubyCodeAccessorMethod
Definition: rubycodeaccessormethod.h:21
DCodeClassField
Definition: dcodeclassfield.h:21
rubycodegenerator.h
postgresqlwriter.h
CodeComment
Text which will be comments.
Definition: codecomment.h:23
Uml::ProgrammingLanguage::JavaScript
Definition: basictypes.h:249
CPPSourceCodeOperation::updateMethodDeclaration
virtual void updateMethodDeclaration()
Update the doc and start text of this method.
Definition: cppsourcecodeoperation.cpp:47
CodeGenFactory::newCodeOperation
CodeOperation * newCodeOperation(ClassifierCodeDocument *ccd, UMLOperation *op)
Definition: codegenfactory.cpp:224
Uml::ProgrammingLanguage::PHP
Definition: basictypes.h:253
CPPSourceCodeAccessorMethod
Definition: cppsourcecodeaccessormethod.h:21
dcodeclassfielddeclarationblock.h
TclWriter
Class TclWriter is a code generator for UMLClassifier objects.
Definition: tclwriter.h:31
idlwriter.h
RubyCodeComment
class RubyCodeComment A Ruby code comment.
Definition: rubycodecomment.h:27
cppwriter.h
MySQLWriter
Class MySQLWriter is a sql code generator for MySQL.
Definition: mysqlwriter.h:26
cppheadercodeaccessormethod.h
CodeClassField::finishInitialization
void finishInitialization()
Finish off initializations of the object.
Definition: codeclassfield.cpp:647
javacodeclassfielddeclarationblock.h
uml.h
CPPSourceCodeAccessorMethod::update
void update()
Must be called before this object is usable.
Definition: cppsourcecodeaccessormethod.cpp:33
DCodeComment
A class representing a D code comment.
Definition: dcodecomment.h:25
RubyCodeClassField
Definition: rubycodeclassfield.h:22
CodeGenerator::initFromParentDocument
virtual void initFromParentDocument()
Initialize this code generator from its parent UMLDoc.
Definition: codegenerator.cpp:308
dcodeaccessormethod.h
ClassifierCodeDocument::synchronize
virtual void synchronize()
Cause this classifier code document to synchronize to current policy.
Definition: classifiercodedocument.cpp:475
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Tue Oct 14 2014 23:05:59 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

umbrello/umbrello

Skip menu "umbrello/umbrello"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages

kdesdk API Reference

Skip menu "kdesdk API Reference"
  • kapptemplate
  • kcachegrind
  • kompare
  • lokalize
  • okteta
  • umbrello
  •   umbrello

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal