ParameterizedTypeImpl.java revision c7dede2138e5b122cb1011a355e4f9f8e6d37856 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package libcore.reflect;
18
19import java.lang.reflect.ParameterizedType;
20import java.lang.reflect.Type;
21import java.util.Arrays;
22import java.util.Objects;
23
24public final class ParameterizedTypeImpl implements ParameterizedType {
25    private final ListOfTypes args;
26    private final ParameterizedTypeImpl ownerType0; // Potentially unresolved.
27    private Type ownerTypeRes; // Potentially unresolved.
28    private Class rawType; // Potentially unresolved.
29    private final String rawTypeName;
30    private final ClassLoader loader;
31
32    public ParameterizedTypeImpl(ParameterizedTypeImpl ownerType, String rawTypeName,
33            ListOfTypes args, ClassLoader loader) {
34        if (args == null) {
35            throw new NullPointerException();
36        }
37        this.ownerType0 = ownerType;
38        this.rawTypeName = rawTypeName;
39        this.args = args;
40        this.loader = loader;
41    }
42
43
44    public Type[] getActualTypeArguments() {
45        return args.getResolvedTypes().clone();
46    }
47
48    public Type getOwnerType() {
49        if (ownerTypeRes == null) {
50            if (ownerType0 != null) {
51                ownerTypeRes = ownerType0.getResolvedType();
52            } else {
53                ownerTypeRes = getRawType().getDeclaringClass();
54            }
55        }
56        return ownerTypeRes;
57    }
58
59    public Class getRawType() {
60        if (rawType == null) {
61            // Here the actual loading of the class has to be performed and the
62            // Exceptions have to be re-thrown TypeNotPresent...
63            // How to deal with member (nested) classes?
64            try {
65                rawType = Class.forName(rawTypeName, false, loader);
66            } catch (ClassNotFoundException e) {
67                throw new TypeNotPresentException(rawTypeName, e);
68            }
69        }
70        return rawType;
71    }
72
73
74    Type getResolvedType() {
75        if (args.getResolvedTypes().length == 0) {
76            return getRawType();
77        } else {
78            return this;
79        }
80    }
81
82    @Override
83    public boolean equals(Object o) {
84        if (!(o instanceof ParameterizedType)) {
85            return false;
86        }
87        ParameterizedType that = (ParameterizedType) o;
88        return Objects.equals(getRawType(), that.getRawType()) &&
89                Objects.equals(getOwnerType(), that.getOwnerType()) &&
90                Arrays.equals(args.getResolvedTypes(), that.getActualTypeArguments());
91    }
92
93    @Override
94    public int hashCode() {
95        return 31 * (31 * Objects.hashCode(getRawType()) + Objects.hashCode(getOwnerType())) +
96            Arrays.hashCode(args.getResolvedTypes());
97    }
98
99    @Override
100    public String toString() {
101        StringBuilder sb = new StringBuilder();
102        sb.append(rawTypeName);
103        if (args.length() > 0) {
104            sb.append("<").append(args).append(">");
105        }
106        return sb.toString();
107    }
108}
109