1 /*
2  * Copyright (C) 2009 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 
17 package signature.compare.model.subst;
18 
19 import signature.model.IArrayType;
20 import signature.model.IClassDefinition;
21 import signature.model.IClassReference;
22 import signature.model.IParameterizedType;
23 import signature.model.IPrimitiveType;
24 import signature.model.ITypeReference;
25 import signature.model.ITypeVariableDefinition;
26 import signature.model.ITypeVariableReference;
27 import signature.model.IWildcardType;
28 import signature.model.impl.SigClassReference;
29 
30 import java.util.ArrayList;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.HashSet;
34 import java.util.Iterator;
35 import java.util.List;
36 import java.util.Map;
37 import java.util.Set;
38 
39 public class ViewpointAdapter {
40 
createTypeMapping( IParameterizedType paramameterizedType, IClassDefinition parameterizedTypeDefinition)41     static Map<ITypeVariableDefinition, ITypeReference> createTypeMapping(
42             IParameterizedType paramameterizedType,
43             IClassDefinition parameterizedTypeDefinition) {
44         List<ITypeVariableDefinition> typeParameters =
45                 parameterizedTypeDefinition.getTypeParameters();
46         List<ITypeReference> actualTypeArguments = paramameterizedType
47                 .getTypeArguments();
48         if (actualTypeArguments == null || typeParameters == null) {
49             return Collections.emptyMap();
50         }
51         Map<ITypeVariableDefinition, ITypeReference> substitution =
52                 new HashMap<ITypeVariableDefinition, ITypeReference>();
53         Iterator<ITypeVariableDefinition> paramsIterator = typeParameters
54                 .iterator();
55         Iterator<ITypeReference> argumentsIterator = actualTypeArguments
56                 .iterator();
57         while (paramsIterator.hasNext() && argumentsIterator.hasNext()) {
58             substitution.put(paramsIterator.next(), argumentsIterator.next());
59         }
60         return substitution;
61     }
62 
substitutedTypeReferences( Set<ITypeReference> original, Map<ITypeVariableDefinition, ITypeReference> mappings)63     public static Set<ITypeReference> substitutedTypeReferences(
64             Set<ITypeReference> original,
65             Map<ITypeVariableDefinition, ITypeReference> mappings) {
66         List<ITypeReference> result = new ArrayList<ITypeReference>(original);
67         return new HashSet<ITypeReference>(substitutedTypeReferences(result,
68                 mappings));
69     }
70 
substitutedTypeReferences( List<ITypeReference> original, Map<ITypeVariableDefinition, ITypeReference> mappings)71     public static List<ITypeReference> substitutedTypeReferences(
72             List<ITypeReference> original,
73             Map<ITypeVariableDefinition, ITypeReference> mappings) {
74         List<ITypeReference> result = new ArrayList<ITypeReference>(original
75                 .size());
76         for (ITypeReference typeReference : original) {
77             result.add(substitutedTypeReference(typeReference, mappings));
78         }
79         return result;
80     }
81 
substitutedTypeReference( ITypeReference original, Map<ITypeVariableDefinition, ITypeReference> mappings)82     public static ITypeReference substitutedTypeReference(
83             ITypeReference original,
84             Map<ITypeVariableDefinition, ITypeReference> mappings) {
85         ITypeReference type = original;
86         if (type instanceof IClassReference) {
87             return new ClassReferenceProjection((IClassReference) original,
88                     mappings);
89         } else if (type instanceof IPrimitiveType) {
90             return type;
91         } else if (type instanceof IArrayType) {
92             return new ArrayTypeProjection((IArrayType) type, mappings);
93         } else if (type instanceof IParameterizedType) {
94             return new ParameterizedTypeProjection((IParameterizedType) type,
95                     mappings);
96         } else if (type instanceof IWildcardType) {
97             return new WildcardTypeProjection((IWildcardType) type, mappings);
98         } else if (type instanceof ITypeVariableReference) {
99             // here happens the substitution
100             ITypeReference subst = mappings.get(((ITypeVariableReference) type)
101                     .getTypeVariableDefinition());
102             return subst != null ? subst : type;
103         }
104         throw new IllegalStateException();
105     }
106 
getReferenceTo(IClassDefinition definition)107     public static IClassReference getReferenceTo(IClassDefinition definition) {
108         return new SigClassReference(new ClassProjection(definition,
109                 new HashMap<ITypeVariableDefinition, ITypeReference>()));
110     }
111 }
112