Method: setFirstToken(Token)

1: package de.fhdw.wtf.common.ast;
2:
3: import de.fhdw.wtf.common.ast.visitor.NameReturnVisitor;
4: import de.fhdw.wtf.common.ast.visitor.NameVisitor;
5: import de.fhdw.wtf.common.ast.visitor.NameVisitorReturnBoolean;
6: import de.fhdw.wtf.common.ast.visitor.NameVisitorReturnName;
7: import de.fhdw.wtf.common.ast.visitor.NameVisitorReturnNameException;
8: import de.fhdw.wtf.common.exception.referencer.InvalidTypeReferenceException;
9: import de.fhdw.wtf.common.token.IdentifierToken;
10: import de.fhdw.wtf.common.token.Token;
11:
12: /**
13: * This class represents a {@link UnqualifiedName}. A {@link Name} is unqualified if contains just the name of a
14: * {@link GroupElement}.
15: *
16: */
17: public final class UnqualifiedName implements Name {
18:         
19:         /**
20:          * generated.
21:          */
22:         private static final long serialVersionUID = 1489081265226782458L;
23:         
24:         /**
25:          * Identifier-Token.
26:          */
27:         private final IdentifierToken identifierToken;
28:         
29:         /**
30:          * This for Multiple Inheritance.
31:          */
32:         private final SyntaxObjectInterface thiis;
33:         
34:         /**
35:          * Constructor of {@link UnqualifiedName}.
36:          *
37:          * @param identifierToken
38:          * identifierToken
39:          * @param lastToken
40:          * lastToken
41:          */
42:         private UnqualifiedName(final IdentifierToken identifierToken, final Token lastToken) {
43:                 this.identifierToken = identifierToken;
44:                 this.thiis = SyntaxObjectConcret.create(identifierToken, lastToken);
45:         }
46:         
47:         /**
48:          * Creates a {@link UnqualifiedName}-Object.
49:          *
50:          * @param identifierToken
51:          * identifierToken
52:          * @param lastToken
53:          * lastToken
54:          * @return The UnqualifiedName-Object
55:          */
56:         public static UnqualifiedName create(final IdentifierToken identifierToken, final Token lastToken) {
57:                 return new UnqualifiedName(identifierToken, lastToken);
58:         }
59:         
60:         /**
61:          * Creates a {@link UnqualifiedName}-Object.
62:          *
63:          * @param identifierToken
64:          * identifierToken
65:          * @return The UnqualifiedName-Object
66:          */
67:         public static UnqualifiedName create(final IdentifierToken identifierToken) {
68:                 return new UnqualifiedName(identifierToken, null);
69:         }
70:         
71:         @Override
72:         public boolean equals(final Object o) {
73:                 if (o instanceof UnqualifiedName) {
74:                         final UnqualifiedName other = (UnqualifiedName) o;
75:                         return this.identifierToken.stringRepresentation()
76:                                         .equals(other.getIdentifierToken().stringRepresentation());
77:                 }
78:                 return false;
79:         }
80:         
81:         @Override
82:         public int hashCode() {
83:                 return this.identifierToken.stringRepresentation().hashCode();
84:         }
85:         
86:         @Override
87:         public Name addName(final IdentifierToken identifier) {
88:                 return this.addName(identifier, null);
89:         }
90:         
91:         @Override
92:         public Name addName(final IdentifierToken identifier, final Token lastToken) {
93:                 final UnqualifiedName rest = UnqualifiedName.create(identifier, lastToken);
94:                 return QualifiedName.create(this, rest, identifier, lastToken);
95:         }
96:         
97:         @Override
98:         public String toString() {
99:                 return this.getIdentifierToken().stringRepresentation();
100:         }
101:         
102:         @Override
103:         public Name visit(final NameVisitorReturnName v) {
104:                 return v.handleUnqualifiedName(this);
105:         }
106:         
107:         @Override
108:         public Name concat(final Name name) {
109:                 return name.visit(new NameVisitorReturnName() {
110:                         
111:                         @Override
112:                         public Name handleUnqualifiedName(final UnqualifiedName unqName) {
113:                                 return UnqualifiedName.this.addName(unqName.getIdentifierToken());
114:                         }
115:                         
116:                         @Override
117:                         public Name handleQualifiedName(final QualifiedName qName) {
118:                                 Name result = UnqualifiedName.this.addName(qName.getFirst().getIdentifierToken());
119:                                 result = result.concat(qName.getRest());
120:                                 return result;
121:                         }
122:                 });
123:         }
124:         
125:         @Override
126:         public <X> X visit(final NameReturnVisitor<X> v) {
127:                 return v.handle(this);
128:         }
129:         
130:         @Override
131:         public UnqualifiedName getLastAddedName() {
132:                 return this;
133:         }
134:         
135:         @Override
136:         public boolean equalsPartial(final Name name) {
137:                 return name.visit(new NameVisitorReturnBoolean() {
138:                         
139:                         @Override
140:                         public boolean handleUnqualifiedName(final UnqualifiedName unqName) {
141:                                 return UnqualifiedName.this.equals(unqName);
142:                         }
143:                         
144:                         @Override
145:                         public boolean handleQualifiedName(final QualifiedName qName) {
146:                                 return UnqualifiedName.this.equals(qName.getFirst());
147:                         }
148:                 });
149:         }
150:         
151:         @Override
152:         public void visit(final NameVisitor v) throws InvalidTypeReferenceException {
153:                 v.handle(this);
154:         }
155:         
156:         @Override
157:         public boolean visit(final NameVisitorReturnBoolean v) {
158:                 return v.handleUnqualifiedName(this);
159:         }
160:         
161:         @Override
162:         public Name visit(final NameVisitorReturnNameException<InvalidTypeReferenceException> v)
163:                         throws InvalidTypeReferenceException {
164:                 return v.handleUnqualifiedName(this);
165:         }
166:         
167:         // // PROJECTIONS ////
168:         
169:         /**
170:          * Get the Identifier-Token.
171:          *
172:          * @return Identifier-Token
173:          */
174:         public IdentifierToken getIdentifierToken() {
175:                 return this.identifierToken;
176:         }
177:         
178:         @Override
179:         public Token getFirstToken() {
180:                 return this.getThis().getFirstToken();
181:         }
182:         
183:         @Override
184:         public void setFirstToken(final Token firstToken) {
185:                 this.getThis().setFirstToken(firstToken);
186:         }
187:         
188:         @Override
189:         public Token getLastToken() {
190:                 return this.getThis().getLastToken();
191:         }
192:         
193:         @Override
194:         public void setLastToken(final Token lastToken) {
195:                 this.getThis().setLastToken(lastToken);
196:         }
197:         
198:         /**
199:          * Returned the This of the Multiple Inheritance.
200:          *
201:          * @return this
202:          */
203:         private SyntaxObjectInterface getThis() {
204:                 return this.thiis;
205:         }
206:         
207: }