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
|
/*******************************************************************************
* Copyright (c) 2009, 2010 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.core.internal;
import java.util.Iterator;
import java.util.ListIterator;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jpt.core.JpaAnnotationDefinitionProvider;
import org.eclipse.jpt.core.JpaAnnotationProvider;
import org.eclipse.jpt.core.resource.java.Annotation;
import org.eclipse.jpt.core.resource.java.AnnotationDefinition;
import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
import org.eclipse.jpt.core.resource.java.JavaResourcePackage;
import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
import org.eclipse.jpt.core.utility.jdt.Attribute;
import org.eclipse.jpt.core.utility.jdt.AnnotatedPackage;
import org.eclipse.jpt.core.utility.jdt.Type;
import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator;
import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
/**
* Delegate to annotation definition providers.
* The platform factory will build an instance of this annotation provider,
* passing in the appropriate array of annotation definition providers necessary
* to build the annotations for the platform (vendor and/or version).
*/
public class GenericJpaAnnotationProvider
implements JpaAnnotationProvider
{
private final JpaAnnotationDefinitionProvider[] annotationDefinitionProviders;
public GenericJpaAnnotationProvider(JpaAnnotationDefinitionProvider... annotationDefinitionProviders) {
super();
this.annotationDefinitionProviders = annotationDefinitionProviders;
}
// ********** convenience methods **********
protected Iterator<String> annotationNames(Iterator<AnnotationDefinition> annotationDefinitions) {
return new TransformationIterator<AnnotationDefinition, String>(annotationDefinitions) {
@Override
protected String transform(AnnotationDefinition annotationDefinition) {
return annotationDefinition.getAnnotationName();
}
};
}
protected AnnotationDefinition selectAnnotationDefinition(Iterator<AnnotationDefinition> annotationDefinitions, String annotationName) {
while (annotationDefinitions.hasNext()) {
AnnotationDefinition annotationDefinition = annotationDefinitions.next();
if (annotationDefinition.getAnnotationName().equals(annotationName)) {
return annotationDefinition;
}
}
return null;
}
// ********** annotation definition providers **********
protected ListIterator<JpaAnnotationDefinitionProvider> annotationDefinitionProviders() {
return new ArrayListIterator<JpaAnnotationDefinitionProvider>(this.annotationDefinitionProviders);
}
// ********** type annotations **********
public Iterator<String> typeAnnotationNames() {
return this.annotationNames(this.typeAnnotationDefinitions());
}
protected Iterator<AnnotationDefinition> typeAnnotationDefinitions() {
return new CompositeIterator<AnnotationDefinition> (
new TransformationIterator<JpaAnnotationDefinitionProvider, Iterator<AnnotationDefinition>>(this.annotationDefinitionProviders()) {
@Override
protected Iterator<AnnotationDefinition> transform(JpaAnnotationDefinitionProvider annotationDefinitionProvider) {
return annotationDefinitionProvider.typeAnnotationDefinitions();
}
}
);
}
public Iterator<String> typeMappingAnnotationNames() {
return this.annotationNames(typeMappingAnnotationDefinitions());
}
protected Iterator<AnnotationDefinition> typeMappingAnnotationDefinitions() {
return new CompositeIterator<AnnotationDefinition> (
new TransformationIterator<JpaAnnotationDefinitionProvider, Iterator<AnnotationDefinition>>(this.annotationDefinitionProviders()) {
@Override
protected Iterator<AnnotationDefinition> transform(JpaAnnotationDefinitionProvider annotationDefinitionProvider) {
return annotationDefinitionProvider.typeMappingAnnotationDefinitions();
}
}
);
}
public Annotation buildTypeAnnotation(JavaResourcePersistentType parent, Type type, String annotationName) {
return this.getTypeAnnotationDefinition(annotationName).buildAnnotation(parent, type);
}
public Annotation buildTypeAnnotation(JavaResourcePersistentType parent, IAnnotation jdtAnnotation) {
return this.getTypeAnnotationDefinition(jdtAnnotation.getElementName()).buildAnnotation(parent, jdtAnnotation);
}
protected AnnotationDefinition getTypeAnnotationDefinition(String annotationName) {
AnnotationDefinition annotationDefinition = this.selectAnnotationDefinition(this.typeAnnotationDefinitions(), annotationName);
if (annotationDefinition == null) {
throw new IllegalArgumentException("unsupported type annotation: " + annotationName); //$NON-NLS-1$
}
return annotationDefinition;
}
public Annotation buildNullTypeAnnotation(JavaResourcePersistentType parent, String annotationName) {
return this.getTypeAnnotationDefinition(annotationName).buildNullAnnotation(parent);
}
// ********** attribute annotations **********
public Iterator<String> attributeAnnotationNames() {
return this.annotationNames(attributeAnnotationDefinitions());
}
protected Iterator<AnnotationDefinition> attributeAnnotationDefinitions() {
return new CompositeIterator<AnnotationDefinition> (
new TransformationIterator<JpaAnnotationDefinitionProvider, Iterator<AnnotationDefinition>>(this.annotationDefinitionProviders()) {
@Override
protected Iterator<AnnotationDefinition> transform(JpaAnnotationDefinitionProvider annotationDefinitionProvider) {
return annotationDefinitionProvider.attributeAnnotationDefinitions();
}
}
);
}
public Annotation buildAttributeAnnotation(JavaResourcePersistentAttribute parent, Attribute attribute, String annotationName) {
return this.getAttributeAnnotationDefinition(annotationName).buildAnnotation(parent, attribute);
}
public Annotation buildAttributeAnnotation(JavaResourcePersistentAttribute parent, IAnnotation jdtAnnotation) {
return this.getAttributeAnnotationDefinition(jdtAnnotation.getElementName()).buildAnnotation(parent, jdtAnnotation);
}
public Annotation buildNullAttributeAnnotation(JavaResourcePersistentAttribute parent, String annotationName) {
return this.getAttributeAnnotationDefinition(annotationName).buildNullAnnotation(parent);
}
protected AnnotationDefinition getAttributeAnnotationDefinition(String annotationName) {
AnnotationDefinition annotationDefinition = this.selectAnnotationDefinition(this.attributeAnnotationDefinitions(), annotationName);
if (annotationDefinition == null) {
throw new IllegalArgumentException("unsupported attribute annotation: " + annotationName); //$NON-NLS-1$
}
return annotationDefinition;
}
// ********** package annotations **********
public Iterator<String> packageAnnotationNames() {
return annotationNames(packageAnnotationDefinitions());
}
protected Iterator<AnnotationDefinition> packageAnnotationDefinitions() {
return new CompositeIterator<AnnotationDefinition> (
new TransformationIterator<JpaAnnotationDefinitionProvider, Iterator<AnnotationDefinition>>(this.annotationDefinitionProviders()) {
@Override
protected Iterator<AnnotationDefinition> transform(JpaAnnotationDefinitionProvider annotationDefinitionProvider) {
return annotationDefinitionProvider.packageAnnotationDefinitions();
}
}
);
}
public Annotation buildPackageAnnotation(JavaResourcePackage parent, AnnotatedPackage pack, String annotationName) {
return this.getPackageAnnotationDefinition(annotationName).buildAnnotation(parent, pack);
}
public Annotation buildPackageAnnotation(JavaResourcePackage parent, IAnnotation jdtAnnotation) {
return this.getPackageAnnotationDefinition(jdtAnnotation.getElementName()).buildAnnotation(parent, jdtAnnotation);
}
public Annotation buildNullPackageAnnotation(JavaResourcePackage parent, String annotationName) {
return this.getPackageAnnotationDefinition(annotationName).buildNullAnnotation(parent);
}
protected AnnotationDefinition getPackageAnnotationDefinition(String annotationName) {
AnnotationDefinition annotationDefinition = this.selectAnnotationDefinition(this.packageAnnotationDefinitions(), annotationName);
if (annotationDefinition == null) {
throw new IllegalArgumentException("unsupported package mapping annotation: " + annotationName); //$NON-NLS-1$
}
return annotationDefinition;
}
}
|
