1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52 package org.codehaus.modello.plugin.java.javasource;
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76 import java.util.ArrayList;
77 import java.util.Enumeration;
78 import java.util.LinkedHashMap;
79 import java.util.List;
80 import java.util.Map;
81
82
83
84
85
86
87
88
89
90
91
92 public class JClass extends JStructure {
93
94
95
96
97 private List<JConstructor> _constructors = null;
98
99
100
101
102 private Map<String, JField> _fields = null;
103
104 private List<JClass> _innerClasses = null;
105
106
107
108
109 private List<JMethod> _methods = null;
110
111
112
113
114 private String _superClass = null;
115
116
117
118
119 private JSourceCode _staticInitializer = new JSourceCode();
120
121
122
123
124
125
126
127 public JClass(String name) throws IllegalArgumentException {
128 super(name);
129 _constructors = new ArrayList<JConstructor>();
130 _fields = new LinkedHashMap<>();
131 _methods = new ArrayList<JMethod>();
132 _innerClasses = new ArrayList<JClass>();
133
134 getJDocComment().appendComment("Class " + getLocalName() + ".");
135 }
136
137
138
139
140
141
142
143
144
145 public void addConstructor(JConstructor constructor) throws IllegalArgumentException {
146 if (constructor == null) throw new IllegalArgumentException("Constructors cannot be null");
147
148 if (constructor.getDeclaringClass() == this) {
149
150
151 if (!_constructors.contains(constructor)) {
152 _constructors.add(constructor);
153 }
154 } else {
155 String err = "The given JConstructor was not created ";
156 err += "by this JClass";
157 throw new IllegalArgumentException(err);
158 }
159 }
160
161
162
163
164
165
166
167
168 public void addField(JField jField) throws IllegalArgumentException {
169 if (jField == null) {
170 throw new IllegalArgumentException("Class members cannot be null");
171 }
172
173 String name = jField.getName();
174
175 if (_fields.get(name) != null) {
176 String err = "duplicate name found: " + name;
177 throw new IllegalArgumentException(err);
178 }
179 _fields.put(name, jField);
180 }
181
182
183
184
185
186
187
188
189
190
191 public void addMember(JMember jMember) throws IllegalArgumentException {
192 if (jMember instanceof JField) addField((JField) jMember);
193 else if (jMember instanceof JMethod) addMethod((JMethod) jMember);
194 else {
195 String error = null;
196 if (jMember == null) {
197 error = "the argument 'jMember' must not be null.";
198 } else {
199 error = "Cannot add JMember '" + jMember.getClass().getName() + "' to JClass, unrecognized type.";
200 }
201 throw new IllegalArgumentException(error);
202 }
203 }
204
205
206
207
208
209
210 public void addMethod(JMethod jMethod) {
211 addMethod(jMethod, true);
212 }
213
214
215
216
217
218
219
220
221
222
223
224 public void addMethod(JMethod jMethod, boolean importReturnType) throws IllegalArgumentException {
225 if (jMethod == null) {
226 throw new IllegalArgumentException("Class methods cannot be null");
227 }
228
229
230
231
232
233 boolean added = false;
234
235 JModifiers modifiers = jMethod.getModifiers();
236
237 if (modifiers.isAbstract()) {
238 getModifiers().setAbstract(true);
239 }
240
241 for (int i = 0; i < _methods.size(); i++) {
242 JMethod tmp = (JMethod) _methods.get(i);
243
244 if (tmp.getModifiers().isPrivate()) {
245 if (!modifiers.isPrivate()) {
246 _methods.add(i, jMethod);
247 added = true;
248 break;
249 }
250 }
251
252 if (jMethod.getName().compareTo(tmp.getName()) < 0) {
253 _methods.add(i, jMethod);
254 added = true;
255 break;
256 }
257 }
258
259 if (!added) _methods.add(jMethod);
260 }
261
262
263
264
265
266
267
268
269 public void addMethods(JMethod[] jMethods) throws IllegalArgumentException {
270 for (JMethod jMethod : jMethods) {
271 addMethod(jMethod);
272 }
273 }
274
275
276
277
278
279
280
281 public JConstructor createConstructor() {
282 return createConstructor(null);
283 }
284
285
286
287
288
289
290
291
292 public JConstructor createConstructor(JParameter[] params) {
293 JConstructor cons = new JConstructor(this);
294 if (params != null) {
295 for (JParameter param : params) {
296 cons.addParameter(param);
297 }
298 }
299 addConstructor(cons);
300 return cons;
301 }
302
303
304
305
306
307
308
309 public JClass createInnerClass(String localname) {
310 if (localname == null) {
311 String err = "argument 'localname' must not be null.";
312 throw new IllegalArgumentException(err);
313 }
314 if (localname.indexOf('.') >= 0) {
315 String err = "The name of an inner-class must not contain a package name.";
316 throw new IllegalArgumentException(err);
317 }
318 String classname = getPackageName();
319 if (classname != null) {
320 classname = classname + "." + localname;
321 } else {
322 classname = localname;
323 }
324
325 JClass innerClass = new JInnerClass(classname);
326 _innerClasses.add(innerClass);
327 return innerClass;
328 }
329
330
331
332
333
334
335
336 public JConstructor getConstructor(int index) {
337 return (JConstructor) _constructors.get(index);
338 }
339
340
341
342
343
344
345 public JConstructor[] getConstructors() {
346
347 int size = _constructors.size();
348 JConstructor[] jcArray = new JConstructor[size];
349
350 for (int i = 0; i < _constructors.size(); i++) {
351 jcArray[i] = _constructors.get(i);
352 }
353 return jcArray;
354 }
355
356
357
358
359
360
361
362
363 public JField getField(String name) {
364 return (JField) _fields.get(name);
365 }
366
367
368
369
370
371 public JField[] getFields() {
372 return _fields.values().toArray(new JField[0]);
373 }
374
375
376
377
378
379
380
381 public JClass[] getInnerClasses() {
382 return _innerClasses.toArray(new JClass[0]);
383 }
384
385
386
387
388
389
390 public JMethod[] getMethods() {
391 int size = _methods.size();
392 JMethod[] marray = new JMethod[size];
393
394 for (int i = 0; i < _methods.size(); i++) {
395 marray[i] = _methods.get(i);
396 }
397 return marray;
398 }
399
400
401
402
403
404
405
406
407
408 public JMethod getMethod(String name, int startIndex) {
409 for (int i = startIndex; i < _methods.size(); i++) {
410 JMethod jMethod = _methods.get(i);
411 if (jMethod.getName().equals(name)) return jMethod;
412 }
413 return null;
414 }
415
416
417
418
419
420
421
422 public JMethod getMethod(int index) {
423 return _methods.get(index);
424 }
425
426
427
428
429
430
431
432
433 public JSourceCode getStaticInitializationCode() {
434 return _staticInitializer;
435 }
436
437
438
439
440
441 public String getSuperClass() {
442 return _superClass;
443 }
444
445
446
447
448
449
450 public void print(JSourceWriter jsw) {
451 print(jsw, false);
452 }
453
454
455
456
457
458
459
460 public void print(JSourceWriter jsw, boolean classOnly) {
461
462 if (jsw == null) {
463 throw new IllegalArgumentException("argument 'jsw' should not be null.");
464 }
465
466 StringBuilder buffer = new StringBuilder();
467
468 if (!classOnly) {
469 printHeader(jsw);
470 printPackageDeclaration(jsw);
471
472
473 List<String> removeImports = null;
474 if (_innerClasses.size() > 0) {
475 removeImports = new ArrayList<String>();
476 for (JClass iClass : _innerClasses) {
477 Enumeration<String> e = iClass.getImports();
478 while (e.hasMoreElements()) {
479 String classname = e.nextElement();
480 if (!hasImport(classname)) {
481 addImport(classname);
482 removeImports.add(classname);
483 }
484 }
485 }
486 }
487 printImportDeclarations(jsw);
488
489
490 if (removeImports != null) {
491 for (int i = 0; i < removeImports.size(); i++) {
492 removeImport(removeImports.get(i));
493 }
494 }
495 }
496
497
498
499
500
501 getJDocComment().print(jsw);
502
503 JAnnotations annotations = getAnnotations();
504 if (annotations != null) annotations.print(jsw);
505
506
507
508
509 buffer.setLength(0);
510
511 JModifiers modifiers = getModifiers();
512 if (modifiers.isPrivate()) {
513 buffer.append("private ");
514 } else if (modifiers.isPublic()) {
515 buffer.append("public ");
516 }
517
518 if (modifiers.isAbstract()) {
519 buffer.append("abstract ");
520 }
521
522 if (this instanceof JInnerClass && modifiers.isStatic()) {
523 buffer.append("static ");
524 }
525
526 if (modifiers.isFinal()) {
527 buffer.append("final ");
528 }
529
530 buffer.append("class ");
531 buffer.append(getLocalName());
532 jsw.writeln(buffer.toString());
533 buffer.setLength(0);
534 jsw.indent();
535
536 if (_superClass != null) {
537 buffer.append("extends ");
538 buffer.append(_superClass);
539 jsw.writeln(buffer.toString());
540 buffer.setLength(0);
541 }
542
543 if (getInterfaceCount() > 0) {
544 buffer.append("implements ");
545
546 Enumeration<String> e = getInterfaces();
547 while (e.hasMoreElements()) {
548 buffer.append(e.nextElement());
549 if (e.hasMoreElements()) buffer.append(", ");
550 }
551
552 jsw.writeln(buffer.toString());
553 buffer.setLength(0);
554 }
555
556 jsw.unindent();
557
558 jsw.writeln('{');
559
560 jsw.indent();
561
562
563
564 if (_fields.size() > 0) {
565 jsw.writeln();
566 jsw.writeln(" //--------------------------/");
567 jsw.writeln(" //- Class/Member Variables -/");
568 jsw.writeln("//--------------------------/");
569 jsw.writeln();
570 }
571
572 for (JField jField : _fields.values()) {
573
574 JDocComment comment = jField.getComment();
575 if (comment != null) comment.print(jsw);
576
577 JAnnotations fieldAnnotations = jField.getAnnotations();
578 if (fieldAnnotations != null) fieldAnnotations.print(jsw);
579
580
581 jsw.write(jField.getModifiers().toString());
582 jsw.write(' ');
583
584 JType type = jField.getType();
585 String typeName = type.toString();
586
587 if (typeName.equals(toString())) {
588 typeName = type.getLocalName();
589 }
590 jsw.write(typeName);
591 jsw.write(' ');
592 jsw.write(jField.getName());
593
594 String init = jField.getInitString();
595 if (init != null) {
596 jsw.write(" = ");
597 jsw.write(init);
598 }
599
600 jsw.writeln(';');
601 jsw.writeln();
602 }
603
604
605
606
607
608 if (!_staticInitializer.isEmpty()) {
609 jsw.writeln();
610 jsw.writeln("static");
611 jsw.writeln("{");
612 _staticInitializer.print(jsw);
613 jsw.writeln("};");
614 jsw.writeln();
615 }
616
617
618 if (_constructors.size() > 0) {
619 jsw.writeln();
620 jsw.writeln(" //----------------/");
621 jsw.writeln(" //- Constructors -/");
622 jsw.writeln("//----------------/");
623 jsw.writeln();
624 }
625 for (int i = 0; i < _constructors.size(); i++) {
626 JConstructor jConstructor = _constructors.get(i);
627 jConstructor.print(jsw);
628 jsw.writeln();
629 }
630
631
632 if (_methods.size() > 0) {
633 jsw.writeln();
634 jsw.writeln(" //-----------/");
635 jsw.writeln(" //- Methods -/");
636 jsw.writeln("//-----------/");
637 jsw.writeln();
638 }
639
640 for (int i = 0; i < _methods.size(); i++) {
641 JMethod jMethod = _methods.get(i);
642 jMethod.print(jsw);
643 jsw.writeln();
644 }
645
646
647 if (_innerClasses.size() > 0) {
648 jsw.writeln();
649 jsw.writeln(" //-----------------/");
650 jsw.writeln(" //- Inner Classes -/");
651 jsw.writeln("//-----------------/");
652 jsw.writeln();
653 }
654 for (int i = 0; i < _innerClasses.size(); i++) {
655 JClass jClass = _innerClasses.get(i);
656 jClass.print(jsw, true);
657 jsw.writeln();
658 }
659
660 for (String sourceCodeEntry : sourceCodeEntries) {
661 jsw.writeln(sourceCodeEntry);
662 }
663
664 jsw.unindent();
665
666 jsw.writeln('}');
667 jsw.flush();
668 }
669
670 private List<String> sourceCodeEntries = new ArrayList<String>();
671
672 public void addSourceCode(String sourceCode) {
673 sourceCodeEntries.add(sourceCode);
674 }
675
676
677
678
679
680
681
682 public boolean removeConstructor(JConstructor constructor) {
683 return _constructors.remove(constructor);
684 }
685
686
687
688
689
690
691
692 public JField removeField(String name) {
693 if (name == null) return null;
694
695 JField field = (JField) _fields.remove(name);
696
697
698
699 return field;
700 }
701
702
703
704
705
706
707
708 public boolean removeField(JField jField) {
709 if (jField == null) return false;
710
711 Object field = _fields.get(jField.getName());
712 if (field == jField) {
713 _fields.remove(jField.getName());
714 return true;
715 }
716
717
718 return false;
719 }
720
721
722
723
724
725
726
727 public boolean removeInnerClass(JClass jClass) {
728 return _innerClasses.remove(jClass);
729 }
730
731
732
733
734
735 public void setSuperClass(String superClass) {
736 _superClass = superClass;
737 }
738
739 final class JInnerClass extends JClass {
740 JInnerClass(String name) {
741 super(name);
742 }
743 }
744 }