Skip to main content
aboutsummaryrefslogtreecommitdiffstats
blob: 9513928c4d7b85d07fb04b7c75256db5aa71623a (plain) (blame)
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
/*******************************************************************************
 * Copyright (c) 2011, 2012 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0, which accompanies this distribution
 * and is available at http://www.eclipse.org/legal/epl-v10.html.
 * 
 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.internal.context.java;

import java.util.HashMap;
import org.eclipse.jpt.common.core.internal.resource.java.source.SourceNode;
import org.eclipse.jpt.common.core.resource.java.Annotation;
import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute;
import org.eclipse.jpt.common.core.resource.java.JavaResourceMember;
import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.core.utility.jdt.TypeBinding;
import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
import org.eclipse.jpt.common.utility.internal.iterables.EmptyListIterable;
import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
import org.eclipse.jpt.jpa.core.context.java.Accessor;

public abstract class AbstractAccessor
	extends AbstractJavaJpaContextNode
	implements Accessor
{

	protected AbstractAccessor(ReadOnlyPersistentAttribute parent) {
		super(parent);
	}

	@Override
	public ReadOnlyPersistentAttribute getParent() {
		return (ReadOnlyPersistentAttribute) super.getParent();
	}

	public ReadOnlyPersistentAttribute getAttribute() {
		return this.getParent();
	}


	// ********** unannotated Java resource member **********

	/**
	 * Wrap another Java resource member and suppress all its annotations.
	 */
	protected abstract class UnannotatedJavaResourceMember<M extends JavaResourceMember>
		extends SourceNode
		implements JavaResourceMember
	{
		protected final M member;

		/**
		 * these are built as needed
		 */
		protected final HashMap<String, Annotation> nullAnnotationsCache = new HashMap<String, Annotation>();


		protected UnannotatedJavaResourceMember(M member) {
			super(member.getParent());
			this.member = member;
		}


		// ********** annotations **********

		public Iterable<Annotation> getAnnotations() {
			return EmptyIterable.instance();
		}

		public int getAnnotationsSize() {
			return 0;
		}

		public Annotation getAnnotation(String annotationName) {
			return null;
		}

		public Annotation getContainerAnnotation(String containerAnnotationName) {
			return null;
		}

		public synchronized Annotation getNonNullAnnotation(String annotationName) {
			Annotation annotation = this.nullAnnotationsCache.get(annotationName);
			if (annotation == null) {
				annotation = this.buildNullAnnotation(annotationName);
				this.nullAnnotationsCache.put(annotationName, annotation);
			}
			return annotation;
		}

		protected abstract Annotation buildNullAnnotation(String annotationName);

		public ListIterable<NestableAnnotation> getAnnotations(String nestableAnnotationName) {
			return EmptyListIterable.instance();
		}

		public int getAnnotationsSize(String nestableAnnotationName) {
			return 0;
		}

		public NestableAnnotation getAnnotation(int index, String nestableAnnotationName) {
			return null;
		}

		public Annotation addAnnotation(String annotationName) {
			throw new UnsupportedOperationException();
		}

		public NestableAnnotation addAnnotation(int index, String nestableAnnotationName) {
			throw new UnsupportedOperationException();
		}

		public void moveAnnotation(int targetIndex, int sourceIndex, String containerAnnotationName) {
			throw new UnsupportedOperationException();
		}

		public void removeAnnotation(String annotationName) {
			throw new UnsupportedOperationException();
		}

		public void removeAnnotation(int index, String nestableAnnotationName) {
			throw new UnsupportedOperationException();
		}

		public Annotation setPrimaryAnnotation(String primaryAnnotationName, Iterable<String> supportingAnnotationNames) {
			throw new UnsupportedOperationException();
		}


		// ********** misc **********

		public Iterable<Annotation> getTopLevelAnnotations() {
			return EmptyIterable.instance();
		}

		public boolean isAnnotated() {
			return false;
		}

		public boolean isAnnotatedWithAnyOf(Iterable<String> annotationNames) {
			return false;
		}

		public boolean isFinal() {
			return this.member.isFinal();
		}

		public boolean isPublic() {
			return this.member.isPublic();
		}

		public boolean isStatic() {
			return this.member.isStatic();
		}

		public boolean isTransient() {
			return this.member.isTransient();
		}

		public boolean isProtected() {
			return this.member.isProtected();
		}

		public boolean isPublicOrProtected() {
			return this.isPublic() || this.isProtected();
		}

		public boolean isFor(String memberName, int occurrence) {
			return this.member.isFor(memberName, occurrence);
		}

		public TextRange getTextRange() {
			// should never be null
			return this.member.getTextRange();
		}

		public TextRange getNameTextRange() {
			// should never be null
			return this.member.getNameTextRange();
		}

		public TextRange getTextRange(String nestableAnnotationName) {
			// should never be null
			return this.member.getTextRange(nestableAnnotationName);
		}
	}

	// ********** unannotated Java resource attribute **********

	/**
	 * Wrap another Java resource attribute and suppress all its annotations.
	 */
	protected abstract class UnannotatedJavaResourceAttribute<A extends JavaResourceAttribute>
		extends UnannotatedJavaResourceMember<A>
		implements JavaResourceAttribute
	{
		public UnannotatedJavaResourceAttribute(A attribute){
			super(attribute);
		}

		// ********** annotations **********

		@Override
		public Annotation buildNullAnnotation(String annotationName) {
			return (annotationName == null) ? null : this.buildNullAnnotation_(annotationName);
		}

		private Annotation buildNullAnnotation_(String annotationName) {
			return this.getAnnotationProvider().buildNullAnnotation(this, annotationName);
		}


		// ********** delegated behavior **********

		@Override
		public JavaResourceType getParent() {
			return this.member.getParent();
		}

		public JavaResourceType getResourceType() {
			return this.member.getResourceType();
		}

		public String getName() {
			return this.member.getName();
		}

		public int getModifiers() {
			return this.member.getModifiers();
		}

		public TypeBinding getTypeBinding() {
			return this.member.getTypeBinding();
		}

		@Override
		public void toString(StringBuilder sb) {
			sb.append(this.getName());
		}
	}
}

Back to the top