1/*
2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package com.sun.tools.internal.xjc.model.nav;
27
28import java.lang.reflect.Type;
29import java.util.Collection;
30
31import com.sun.codemodel.internal.JClass;
32import com.sun.xml.internal.bind.v2.model.nav.Navigator;
33import com.sun.xml.internal.bind.v2.runtime.Location;
34
35/**
36 * {@link Navigator} implementation for XJC.
37 *
38 * Most of the Navigator methods are used for parsing the model, which doesn't happen
39 * in XJC. So Most of the methods aren't really implemented. Implementations should
40 * be filled in as needed.
41 *
42 * @author Kohsuke Kawaguchi
43 */
44public final class NavigatorImpl implements Navigator<NType,NClass,Void,Void> {
45    public static final NavigatorImpl theInstance = new NavigatorImpl();
46
47    private NavigatorImpl() {
48    }
49
50    public NClass getSuperClass(NClass nClass) {
51        throw new UnsupportedOperationException();
52    }
53
54    public NType getBaseClass(NType nt, NClass base) {
55        if(nt instanceof EagerNType) {
56            EagerNType ent = (EagerNType) nt;
57            if (base instanceof EagerNClass) {
58                EagerNClass enc = (EagerNClass) base;
59                return create(Utils.REFLECTION_NAVIGATOR.getBaseClass(ent.t, enc.c));
60            }
61            // lazy class can never be a base type of an eager type
62            return null;
63        }
64        if (nt instanceof NClassByJClass) {
65            NClassByJClass nnt = (NClassByJClass) nt;
66            if (base instanceof EagerNClass) {
67                EagerNClass enc = (EagerNClass) base;
68                return ref(nnt.clazz.getBaseClass(enc.c));
69            }
70        }
71
72        throw new UnsupportedOperationException();
73    }
74
75    public String getClassName(NClass nClass) {
76        throw new UnsupportedOperationException();
77    }
78
79    public String getTypeName(NType type) {
80        return type.fullName();
81    }
82
83    public String getClassShortName(NClass nClass) {
84        throw new UnsupportedOperationException();
85    }
86
87    public Collection<? extends Void> getDeclaredFields(NClass nClass) {
88        throw new UnsupportedOperationException();
89    }
90
91    public Void getDeclaredField(NClass clazz, String fieldName) {
92        throw new UnsupportedOperationException();
93    }
94
95    public Collection<? extends Void> getDeclaredMethods(NClass nClass) {
96        throw new UnsupportedOperationException();
97    }
98
99    public NClass getDeclaringClassForField(Void aVoid) {
100        throw new UnsupportedOperationException();
101    }
102
103    public NClass getDeclaringClassForMethod(Void aVoid) {
104        throw new UnsupportedOperationException();
105    }
106
107    public NType getFieldType(Void aVoid) {
108        throw new UnsupportedOperationException();
109    }
110
111    public String getFieldName(Void aVoid) {
112        throw new UnsupportedOperationException();
113    }
114
115    public String getMethodName(Void aVoid) {
116        throw new UnsupportedOperationException();
117    }
118
119    public NType getReturnType(Void aVoid) {
120        throw new UnsupportedOperationException();
121    }
122
123    public NType[] getMethodParameters(Void aVoid) {
124        throw new UnsupportedOperationException();
125    }
126
127    public boolean isStaticMethod(Void aVoid) {
128        throw new UnsupportedOperationException();
129    }
130
131    public boolean isFinalMethod(Void aVoid) {
132        throw new UnsupportedOperationException();
133    }
134
135    public boolean isSubClassOf(NType sub, NType sup) {
136        throw new UnsupportedOperationException();
137    }
138
139    public NClass ref(Class c) {
140        return create(c);
141    }
142
143    public NClass ref(JClass c) {
144        if(c==null)     return null;
145        return new NClassByJClass(c);
146    }
147
148    public NType use(NClass nc) {
149        return nc;
150    }
151
152    public NClass asDecl(NType nt) {
153        if(nt instanceof NClass)
154            return (NClass)nt;
155        else
156            return null;
157    }
158
159    public NClass asDecl(Class c) {
160        return ref(c);
161    }
162
163    public boolean isArray(NType nType) {
164        throw new UnsupportedOperationException();
165    }
166
167    public boolean isArrayButNotByteArray(NType t) {
168        throw new UnsupportedOperationException();
169    }
170
171
172    public NType getComponentType(NType nType) {
173        throw new UnsupportedOperationException();
174    }
175
176    public NType getTypeArgument(NType nt, int i) {
177        if (nt instanceof EagerNType) {
178            EagerNType ent = (EagerNType) nt;
179            return create(Utils.REFLECTION_NAVIGATOR.getTypeArgument(ent.t,i));
180        }
181        if (nt instanceof NClassByJClass) {
182            NClassByJClass nnt = (NClassByJClass) nt;
183            return ref(nnt.clazz.getTypeParameters().get(i));
184        }
185
186        throw new UnsupportedOperationException();
187    }
188
189    public boolean isParameterizedType(NType nt) {
190        if (nt instanceof EagerNType) {
191            EagerNType ent = (EagerNType) nt;
192            return Utils.REFLECTION_NAVIGATOR.isParameterizedType(ent.t);
193        }
194        if (nt instanceof NClassByJClass) {
195            NClassByJClass nnt = (NClassByJClass) nt;
196            return nnt.clazz.isParameterized();
197        }
198
199        throw new UnsupportedOperationException();
200    }
201
202    public boolean isPrimitive(NType type) {
203        throw new UnsupportedOperationException();
204    }
205
206    public NType getPrimitive(Class primitiveType) {
207        return create(primitiveType);
208    }
209
210    @SuppressWarnings("FinalStaticMethod")
211    public static final NType create(Type t) {
212        if(t==null)     return null;
213        if(t instanceof Class)
214            return create((Class)t);
215
216        return new EagerNType(t);
217    }
218
219    public static NClass create( Class c ) {
220        if(c==null)     return null;
221        return new EagerNClass(c);
222    }
223
224    /**
225     * Creates a {@link NType} representation for a parameterized type
226     * {@code RawType<ParamType1,ParamType2,...> }.
227     */
228    public static NType createParameterizedType( NClass rawType, NType... args ) {
229        return new NParameterizedType(rawType,args);
230    }
231
232    public static NType createParameterizedType( Class rawType, NType... args ) {
233        return new NParameterizedType(create(rawType),args);
234    }
235
236    public Location getClassLocation(final NClass c) {
237        // not really needed for XJC but doesn't hurt to have one
238        return new Location() {
239            @Override
240            public String toString() {
241                return c.fullName();
242            }
243        };
244    }
245
246    public Location getFieldLocation(Void v) {
247        throw new IllegalStateException();
248    }
249
250    public Location getMethodLocation(Void v) {
251        throw new IllegalStateException();
252    }
253
254    public boolean hasDefaultConstructor(NClass nClass) {
255        throw new UnsupportedOperationException();
256    }
257
258    public boolean isStaticField(Void aVoid) {
259        throw new IllegalStateException();
260    }
261
262    public boolean isPublicMethod(Void aVoid) {
263        throw new IllegalStateException();
264    }
265
266    public boolean isPublicField(Void aVoid) {
267        throw new IllegalStateException();
268    }
269
270    public boolean isEnum(NClass c) {
271        return isSubClassOf(c,create(Enum.class));
272    }
273
274    public <T> NType erasure(NType type) {
275        if(type instanceof NParameterizedType) {
276            NParameterizedType pt = (NParameterizedType) type;
277            return pt.rawType;
278        }
279        return type;
280    }
281
282    public boolean isAbstract(NClass clazz) {
283        return clazz.isAbstract();
284    }
285
286    /**
287     * @deprecated
288     *      no class generated by XJC is final.
289     */
290    public boolean isFinal(NClass clazz) {
291        return false;
292    }
293
294    public Void[] getEnumConstants(NClass clazz) {
295        throw new UnsupportedOperationException();
296    }
297
298    public NType getVoidType() {
299        return ref(void.class);
300    }
301
302    public String getPackageName(NClass clazz) {
303        // TODO: implement this method later
304        throw new UnsupportedOperationException();
305    }
306
307    @Override
308    public NClass loadObjectFactory(NClass referencePoint, String pkg) {
309        throw new UnsupportedOperationException();
310    }
311
312    public boolean isBridgeMethod(Void method) {
313        throw new UnsupportedOperationException();
314    }
315
316    public boolean isOverriding(Void method,NClass clazz) {
317        throw new UnsupportedOperationException();
318    }
319
320    public boolean isInterface(NClass clazz) {
321        throw new UnsupportedOperationException();
322    }
323
324    public boolean isTransient(Void f) {
325        throw new UnsupportedOperationException();
326    }
327
328    public boolean isInnerClass(NClass clazz) {
329        throw new UnsupportedOperationException();
330    }
331
332    @Override
333    public boolean isSameType(NType t1, NType t2) {
334         throw new UnsupportedOperationException();
335    }
336}
337