wamblee.org Git - utils/blob - 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 }