Method: addAspectOperation(GenAspectOperation)

1: package de.fhdw.wtf.generator.java.generatorModel;
2:
3: import java.util.Collection;
4: import java.util.Vector;
5:
6: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitor;
7: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitorException;
8: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitorReturn;
9: import de.fhdw.wtf.generator.java.visitor.GenTypeVisitorException;
10:
11: public final class GenAspect extends GenClassClass {
12:         
13:         private final Collection<GenJoinpoint> joinpoints;
14:         private final Collection<GenAdvice> advices;
15:         private final Collection<GenDeclareInheritance> declareParents;
16:         private final Collection<GenAspectOperation> aspectOperations;
17:         private final Collection<GenAspectAttribute> aspectAttributes;
18:         
19:         private GenAspect(final String name,
20:                         final Collection<GenJavaOperation> operations,
21:                         final Collection<GenAspectOperation> aspectOperations,
22:                         final Collection<GenInterfaceClass> impl,
23:                         final Collection<GenJavaAttribute> attributes,
24:                         final Collection<GenAspectAttribute> aspectAttributes,
25:                         final Collection<GenClassModifier> modifiers,
26:                         final Collection<GenJavaOperation> constructors,
27:                         final GenClassClass ext,
28:                         final GenPackage packag,
29:                         final GenComment comment,
30:                         final String nonGenPart) {
31:                 super(name, operations, impl, attributes, modifiers, constructors, ext, packag, comment, nonGenPart);
32:                 this.aspectAttributes = aspectAttributes;
33:                 this.aspectOperations = aspectOperations;
34:                 this.joinpoints = new Vector<>();
35:                 this.advices = new Vector<>();
36:                 this.declareParents = new Vector<>();
37:         }
38:         
39:         public static GenAspect create(final String name,
40:                         final Collection<GenJavaOperation> operations,
41:                         final Collection<GenAspectOperation> aspectOperations,
42:                         final Collection<GenInterfaceClass> impl,
43:                         final Collection<GenJavaAttribute> attributes,
44:                         final Collection<GenAspectAttribute> aspectAttributes,
45:                         final Collection<GenClassModifier> modifiers,
46:                         final Collection<GenJavaOperation> constructors,
47:                         final GenClassClass ext,
48:                         final GenPackage packag,
49:                         final GenComment comment,
50:                         final String nonGenPart) {
51:                 return new GenAspect(name, operations, aspectOperations, impl, attributes, aspectAttributes, modifiers,
52:                                 constructors, ext, packag, comment, nonGenPart);
53:         }
54:         
55:         @Override
56:         public void accept(final GenClassClassVisitor visitor) {
57:                 visitor.handle(this);
58:         }
59:         
60:         @Override
61:         public <X> X accept(final GenClassClassVisitorReturn<X> visitor) {
62:                 return visitor.handle(this);
63:         }
64:         
65:         public Collection<GenAdvice> getAdvices() {
66:                 return this.advices;
67:         }
68:         
69:         public Collection<GenJoinpoint> getJoinpoints() {
70:                 return this.joinpoints;
71:         }
72:         
73:         public Collection<GenDeclareInheritance> getDeclareParents() {
74:                 return this.declareParents;
75:         }
76:         
77:         public void addDeclareParents(final GenDeclareInheritance declareInheritance) {
78:                 this.declareParents.add(declareInheritance);
79:         }
80:         
81:         public Collection<GenAttribute> getAllAttributes() {
82:                 final Collection<GenAttribute> result = new Vector<>();
83:                 result.addAll(super.getAttributes());
84:                 result.addAll(this.aspectAttributes);
85:                 return result;
86:         }
87:         
88:         public Collection<GenOperation> getAllOperations() {
89:                 final Collection<GenOperation> result = new Vector<>();
90:                 result.addAll(super.getOperationsInner());
91:                 result.addAll(this.aspectOperations);
92:                 return result;
93:         }
94:         
95:         public void addAspectAtt(final GenAspectAttribute attr) {
96:                 this.aspectAttributes.add(attr);
97:         }
98:         
99:         public Collection<GenAspectOperation> getAspectOperations() {
100:                 return this.aspectOperations;
101:         }
102:         
103:         public void addAspectOperation(final GenAspectOperation newOperation) {
104:                 this.aspectOperations.add(newOperation);
105:         }
106:         
107:         @Override
108:         public <X extends java.lang.Exception> void accept(final GenTypeVisitorException<X> visitor) throws X {
109:                 visitor.handle(this);
110:         }
111:         
112:         @Override
113:         public String toString() {
114:                 return this.getName();
115:         }
116:         
117:         @Override
118:         public String getFileEnding() {
119:                 return ".aj";
120:         }
121:         
122:         @Override
123:         public <Y extends Exception> void accept(final GenClassClassVisitorException<Y> visitor) throws Y {
124:                 visitor.handle(this);
125:         }
126: }