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