← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/kdesdk/intrepid-updates

« back to all changes in this revision

Viewing changes to umbrello/umbrello/codegenerators/codegenfactory.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2008-05-28 10:11:43 UTC
  • mto: This revision was merged to the branch mainline in revision 37.
  • Revision ID: james.westby@ubuntu.com-20080528101143-gzc3styjz1b70zxu
Tags: upstream-4.0.80
Import upstream version 4.0.80

Show diffs side-by-side

added added

removed removed

Lines of Context:
umbrello/umbrello/codegenerators/codegenfactory.cpp
36
36
#include "dwriter.h"
37
37
#include "idlwriter.h"
38
38
#include "javawriter.h"
 
39
#include "mysqlwriter.h"
39
40
#include "pascalwriter.h"
40
41
#include "perlwriter.h"
41
42
#include "phpwriter.h"
42
43
#include "php5writer.h"
 
44
#include "postgresqlwriter.h"
43
45
#include "pythonwriter.h"
44
46
#include "rubywriter.h"
45
47
#include "sqlwriter.h"
50
52
 
51
53
// the new
52
54
#include "cppcodegenerator.h"
 
55
#include "dcodegenerator.h"
53
56
#include "javacodegenerator.h"
54
57
#include "rubycodegenerator.h"
55
58
 
56
59
#include "cppheadercodedocument.h"
57
60
#include "cppsourcecodedocument.h"
 
61
#include "dclassifiercodedocument.h"
58
62
#include "javaclassifiercodedocument.h"
59
63
#include "rubyclassifiercodedocument.h"
60
64
#include "javaantcodedocument.h"
61
65
 
62
66
#include "cppheadercodeoperation.h"
63
67
#include "cppsourcecodeoperation.h"
 
68
#include "dcodeoperation.h"
64
69
#include "javacodeoperation.h"
65
70
#include "rubycodeoperation.h"
66
71
 
67
72
#include "cppcodeclassfield.h"
 
73
#include "dcodeclassfield.h"
68
74
#include "javacodeclassfield.h"
69
75
#include "rubycodeclassfield.h"
70
76
 
71
77
#include "cppheadercodeaccessormethod.h"
72
78
#include "cppsourcecodeaccessormethod.h"
 
79
#include "dcodeaccessormethod.h"
73
80
#include "javacodeaccessormethod.h"
74
81
#include "rubycodeaccessormethod.h"
75
82
 
76
83
#include "cppheadercodeclassfielddeclarationblock.h"
77
84
#include "cppsourcecodeclassfielddeclarationblock.h"
 
85
#include "dcodeclassfielddeclarationblock.h"
78
86
#include "javacodeclassfielddeclarationblock.h"
79
87
#include "rubycodeclassfielddeclarationblock.h"
80
88
 
81
89
#include "cppcodedocumentation.h"
 
90
#include "dcodecomment.h"
82
91
#include "javacodecomment.h"
83
92
#include "rubycodecomment.h"
84
93
#include "xmlcodecomment.h"
85
94
 
86
95
#include "cppcodegenerationpolicy.h"
 
96
#include "dcodegenerationpolicy.h"
87
97
#include "javacodegenerationpolicy.h"
88
98
#include "rubycodegenerationpolicy.h"
89
99
 
92
102
CodeGenerator* createObject(Uml::Programming_Language pl)  {
93
103
    CodeGenerator* obj = 0;
94
104
    Settings::OptionState optionState = Settings::getOptionState();
95
 
    UMLApp::app()->setPolicyExt(NULL);
96
105
    switch (pl) {
97
106
        case Uml::pl_Ada:
98
107
            obj = new AdaWriter();
107
116
            } else {
108
117
                obj = new CppWriter();
109
118
            }
110
 
            {
111
 
                CPPCodeGenerationPolicy *p =
112
 
                    new CPPCodeGenerationPolicy(UMLApp::app()->getConfig());
113
 
                UMLApp::app()->setPolicyExt(p);
114
 
            }
115
119
            break;
116
120
        case Uml::pl_CSharp:
117
121
            obj = new CSharpWriter();
118
122
            break;
119
123
        case Uml::pl_D:
120
 
            obj = new DWriter();
 
124
            if (optionState.generalState.newcodegen) {
 
125
                obj = new DCodeGenerator();
 
126
                obj->connect_newcodegen_slots();
 
127
            } else {
 
128
                obj = new DWriter();
 
129
            }
121
130
            break;
122
131
        case Uml::pl_IDL:
123
132
            obj = new IDLWriter();
126
135
            if (optionState.generalState.newcodegen) {
127
136
                obj = new JavaCodeGenerator();
128
137
                obj->connect_newcodegen_slots();
129
 
                JavaCodeGenerationPolicy *p =
130
 
                    new JavaCodeGenerationPolicy(UMLApp::app()->getConfig());
131
 
                UMLApp::app()->setPolicyExt(p);
132
 
            } else
 
138
            } else {
133
139
                obj = new JavaWriter();
 
140
            }
134
141
            break;
135
142
        case Uml::pl_JavaScript:
136
143
            obj = new JSWriter();
137
144
            break;
 
145
        case Uml::pl_MySQL:
 
146
            obj = new MySQLWriter();
 
147
            break;
138
148
        case Uml::pl_PHP:
139
149
            obj = new PhpWriter();
140
150
            break;
147
157
        case Uml::pl_Perl:
148
158
            obj = new PerlWriter();
149
159
            break;
 
160
        case Uml::pl_PostgreSQL:
 
161
            obj = new PostgreSQLWriter();
 
162
            break;
150
163
        case Uml::pl_Python:
151
164
            obj = new PythonWriter();
152
165
            break;
154
167
            if (optionState.generalState.newcodegen) {
155
168
                obj = new RubyCodeGenerator();
156
169
                obj->connect_newcodegen_slots();
157
 
                RubyCodeGenerationPolicy *p =
158
 
                    new RubyCodeGenerationPolicy(UMLApp::app()->getConfig());
159
 
                UMLApp::app()->setPolicyExt(p);
160
 
            } else
 
170
             } else
161
171
                obj = new RubyWriter();
162
172
            break;
163
173
        case Uml::pl_SQL:
170
180
            obj = new XMLSchemaWriter();
171
181
            break;
172
182
        default:
173
 
            kWarning() << "cannot create object of type " << pl
 
183
            uWarning() << "cannot create object of type " << pl
174
184
                        << ". Type unknown" << endl;
175
185
            break;
176
186
    }
 
187
 
 
188
    UMLApp::app()->setPolicyExt(CodeGenFactory::newCodeGenPolicyExt(pl));
177
189
    if (obj)
178
190
        obj->initFromParentDocument();
179
191
    return obj;
189
201
        case Uml::pl_Cpp:
190
202
            retval = new CPPSourceCodeDocument(c);
191
203
            break;
 
204
        case Uml::pl_D:
 
205
            retval = new DClassifierCodeDocument(c);
 
206
            break;
192
207
        case Uml::pl_Java:
193
208
            retval = new JavaClassifierCodeDocument(c);
194
209
            break;
209
224
        case Uml::pl_Cpp:
210
225
            {
211
226
                CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(ccd);
212
 
                if (hcd)
213
 
                    return new CPPHeaderCodeOperation(hcd, op);
 
227
                if (hcd) {
 
228
                    CPPHeaderCodeOperation *cpphcd = new CPPHeaderCodeOperation(hcd, op);
 
229
                    cpphcd->updateMethodDeclaration();
 
230
                    cpphcd->updateContent();
 
231
                    return cpphcd;
 
232
                }
214
233
                CPPSourceCodeDocument *scd = dynamic_cast<CPPSourceCodeDocument*>(ccd);
215
 
                if (scd)
216
 
                    return new CPPSourceCodeOperation(scd, op);
 
234
                if (scd) {
 
235
                    CPPSourceCodeOperation *cppscd = new CPPSourceCodeOperation(scd, op);
 
236
                    cppscd->updateMethodDeclaration();
 
237
                    cppscd->updateContent();
 
238
                    return cppscd;
 
239
                }
217
240
            }
218
241
            break;
 
242
        case Uml::pl_D:
 
243
            retval = new DCodeOperation(dynamic_cast<DClassifierCodeDocument*>(ccd), op);
 
244
            retval->updateMethodDeclaration();
 
245
            retval->updateContent();
 
246
            break;
219
247
        case Uml::pl_Java:
220
248
            retval = new JavaCodeOperation(dynamic_cast<JavaClassifierCodeDocument*>(ccd), op);
 
249
            retval->updateMethodDeclaration();
 
250
            retval->updateContent();
221
251
            break;
222
252
        case Uml::pl_Ruby:
223
253
            retval = new RubyCodeOperation(dynamic_cast<RubyClassifierCodeDocument*>(ccd), op);
 
254
            retval->updateMethodDeclaration();
 
255
            retval->updateContent();
224
256
            break;
225
257
        default:
226
258
            break;
235
267
        case Uml::pl_Cpp:
236
268
            retval = new CPPCodeClassField(ccd, at);
237
269
            break;
 
270
        case Uml::pl_D:
 
271
            retval = new DCodeClassField(ccd, at);
 
272
            break;
238
273
        case Uml::pl_Java:
239
274
            retval = new JavaCodeClassField(ccd, at);
240
275
            break;
254
289
        case Uml::pl_Cpp:
255
290
            retval = new CPPCodeClassField(ccd, role);
256
291
            break;
 
292
        case Uml::pl_D:
 
293
            retval = new DCodeClassField(ccd, role);
 
294
            break;
257
295
        case Uml::pl_Java:
258
296
            retval = new JavaCodeClassField(ccd, role);
259
297
            break;
263
301
        default:
264
302
            break;
265
303
    }
 
304
    retval->finishInitialization();
266
305
    return retval;
267
306
}
268
307
 
285
324
                }
286
325
            }
287
326
            break;
 
327
        case Uml::pl_D:
 
328
            {
 
329
                DCodeAccessorMethod *jcam = new DCodeAccessorMethod(cf, type);
 
330
                jcam->update();
 
331
                retval = jcam;
 
332
                retval->setOverallIndentationLevel(1);
 
333
            }
 
334
            break;
288
335
        case Uml::pl_Java:
289
336
            {
290
337
                JavaCodeAccessorMethod *jcam = new JavaCodeAccessorMethod(cf, type);
314
361
        case Uml::pl_Cpp:
315
362
            {
316
363
                CPPHeaderCodeDocument *hcd = dynamic_cast<CPPHeaderCodeDocument*>(cd);
317
 
                if (hcd)
318
 
                    return new CPPHeaderCodeClassFieldDeclarationBlock(cf);
 
364
                if (hcd) {
 
365
                    CPPHeaderCodeClassFieldDeclarationBlock * cpphcd = new CPPHeaderCodeClassFieldDeclarationBlock(cf);
 
366
                    cpphcd->updateContent();
 
367
                    return cpphcd;
 
368
                }
319
369
                CPPSourceCodeDocument *scd = dynamic_cast<CPPSourceCodeDocument*>(cd);
320
 
                if (scd)
321
 
                    return new CPPSourceCodeClassFieldDeclarationBlock(cf);
 
370
                if (scd) {
 
371
                    CPPSourceCodeClassFieldDeclarationBlock *cppscd = new CPPSourceCodeClassFieldDeclarationBlock(cf);
 
372
                    cppscd->updateContent();
 
373
                    return cppscd;
 
374
                }
322
375
            }
323
376
            break;
 
377
        case Uml::pl_D:
 
378
            retval = new DCodeClassFieldDeclarationBlock(cf);
 
379
            retval->updateContent();
 
380
            break;
324
381
        case Uml::pl_Java:
325
382
            retval = new JavaCodeClassFieldDeclarationBlock(cf);
 
383
            retval->updateContent();
326
384
            break;
327
385
        case Uml::pl_Ruby:
328
386
            retval = new RubyCodeClassFieldDeclarationBlock(cf);
 
387
            retval->updateContent();
329
388
            break;
330
389
        default:
331
390
            break;
340
399
                dynamic_cast<CPPSourceCodeDocument*>(cd))
341
400
                return new CPPCodeDocumentation(cd);
342
401
            break;
 
402
        case Uml::pl_D:
 
403
            if (dynamic_cast<DClassifierCodeDocument*>(cd))
 
404
                return new DCodeComment(cd);
 
405
            break;
343
406
        case Uml::pl_Java:
344
407
            if (dynamic_cast<JavaClassifierCodeDocument*>(cd))
345
408
                return new JavaCodeComment(cd);
356
419
    return new CodeComment(cd);
357
420
}
358
421
 
 
422
CodeGenPolicyExt* newCodeGenPolicyExt(Uml::Programming_Language pl) {
 
423
 
 
424
    Settings::OptionState optionState = Settings::getOptionState();
 
425
 
 
426
    if ( pl == Uml::pl_Cpp )
 
427
        return new CPPCodeGenerationPolicy();
 
428
 
 
429
    if ( optionState.generalState.newcodegen ) {
 
430
       switch( pl ) {
 
431
          case Uml::pl_Java:
 
432
              return new JavaCodeGenerationPolicy();
 
433
              break;
 
434
          case Uml::pl_D:
 
435
              return new DCodeGenerationPolicy();
 
436
              break;
 
437
          case Uml::pl_Ruby:
 
438
              return new RubyCodeGenerationPolicy();
 
439
              break;
 
440
          default:
 
441
              return NULL;
 
442
        }
 
443
    }
 
444
 
 
445
    return NULL;
 
446
 
 
447
}
 
448
 
 
449
 
359
450
}  // end namespace CodeGenFactory
360
451
 
 
452