(no commit message)
[utils] / system / general / src / main / java / org / wamblee / system / DefaultRequiredInterface.java
1 /*
2  * Copyright 2007 the original author or authors.
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 package org.wamblee.system;
17
18 import java.util.Arrays;
19
20 public class DefaultRequiredInterface implements RequiredInterface {
21
22         private String _name;
23         private Class[] _required;
24         private ProvidedInterface _provider; 
25         
26         public DefaultRequiredInterface(String aName, Class aInterface) {
27                 this(aName, new Class[] { aInterface }); 
28         }
29
30         public DefaultRequiredInterface(String aName, Class[] aInterfaces) {
31                 _name = aName; 
32                 _required = aInterfaces; 
33         }
34
35         @Override
36         public String getName() {
37                 return _name;
38         }
39         
40         @Override
41         public boolean implementedBy(ProvidedInterface aDescriptor) {
42                 Class[] provided = aDescriptor.getInterfaceTypes();
43                 for (Class required : _required) {
44                         if ( !serviceProvided(required, provided)) { 
45                                 return false; 
46                         }
47                 }
48                 // all required interfaces are provided.
49                 return true; 
50         }
51         
52         /**
53          * Check if the required interface is implemented by one of the provided interfaces. 
54          * @param aRequired required interface
55          * @param aProvided Provided interfaces.
56          * @return
57          */
58         private boolean serviceProvided(Class aRequired, Class[] aProvided) { 
59                 for (Class provided: aProvided) {
60                         try {
61                                 provided.asSubclass(aRequired);
62                                 return true; 
63                         } catch (ClassCastException e) {
64                                 // No match, try the next one.
65                         }
66                 }
67                 return false; 
68         }
69         
70         @Override
71         public ProvidedInterface getProvider() {
72                 return _provider; 
73         }
74         
75         @Override
76         public void setProvider(ProvidedInterface aProvider) {
77                 _provider = aProvider;  
78         }
79
80         @Override
81         public <T> T getImplementation(Class<T> aClass) {
82                 if ( _provider == null ) { 
83                         return null; 
84                 }
85                 return (T)_provider.getImplementation();
86         }
87         
88         @Override
89         public boolean equals(Object obj) {
90                 if ( !(obj instanceof DefaultRequiredInterface)) { 
91                         return false; 
92                 }
93                 DefaultRequiredInterface descr = (DefaultRequiredInterface)obj;
94                 if ( _required.length != descr._required.length ) { 
95                         return false; 
96                 }
97                 String[] interfaces1 = new String[_required.length];
98                 String[] interfaces2 = new String[_required.length];
99                 for (int i = 0; i < _required.length; i++) {  
100                         interfaces1[i] = _required[i].getName();
101                         interfaces2[i] = descr._required[i].getName();
102                 }
103                 Arrays.sort(interfaces1);
104                 Arrays.sort(interfaces2);
105                 return Arrays.equals(interfaces1, interfaces2);
106         }
107
108         @Override
109         public int hashCode() {
110                 return _required.hashCode(); 
111         }
112         
113         @Override
114         public String toString() {
115                 StringBuffer buf = new StringBuffer();
116                 for (Class intf: _required) { 
117                         buf.append("." + intf.getName());
118                 }
119                 return buf.toString();
120         }
121 }