wamblee.org Git - utils/blob - system/general/src/main/java/org/wamblee/system/core/DefaultRequiredInterface.java

   1 /*
   2  * Copyright 2005-2010 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 org.wamblee.reflection.ReflectionUtils;
  19
  20 import java.util.Arrays;
  21
  22 /**
  23  *
  24  * @author $author$
  25  * @version $Revision$
  26  */
  27 public class DefaultRequiredInterface implements RequiredInterface {
  28     private String name;
  29
  30     private boolean optional;
  31
  32     private Class[] required;
  33
  34     private ProvidedInterface provider;
  35
  36     /**
  37      * Creates a new DefaultRequiredInterface object.
  38      *
  39      */
  40     public DefaultRequiredInterface(String aName, Class aInterface) {
  41         this(aName, new Class[] { aInterface });
  42     }
  43
  44     /**
  45      * Creates a new DefaultRequiredInterface object.
  46      *
  47      */
  48     public DefaultRequiredInterface(String aName, Class[] aInterfaces) {
  49         this(aName, aInterfaces, false);
  50     }
  51
  52     /**
  53      * Creates a new DefaultRequiredInterface object.
  54      *
  55      */
  56     public DefaultRequiredInterface(String aName, Class aInterface,
  57         boolean aIsOptional) {
  58         this(aName, new Class[] { aInterface }, aIsOptional);
  59     }
  60
  61     /**
  62      * Creates a new DefaultRequiredInterface object.
  63      *
  64      */
  65     public DefaultRequiredInterface(String aName, Class[] aInterfaces,
  66         boolean aIsOptional) {
  67         name = aName;
  68         optional = aIsOptional;
  69         required = aInterfaces;
  70     }
  71
  72     @Override
  73     public String getName() {
  74         return name;
  75     }
  76
  77     @Override
  78     public boolean isOptional() {
  79         return optional;
  80     }
  81
  82     @Override
  83     public boolean implementedBy(ProvidedInterface aDescriptor) {
  84         Class[] provided = aDescriptor.getInterfaceTypes();
  85
  86         for (Class requiredIntf : required) {
  87             if (!serviceProvided(requiredIntf, provided)) {
  88                 return false;
  89             }
  90         }
  91
  92         // all required interfaces are provided.
  93         return true;
  94     }
  95
  96     /**
  97      * Check if the required interface is implemented by one of the provided
  98      * interfaces.
  99      *
 100      * @param aRequired
 101      *            required interface
 102      * @param aProvided
 103      *            Provided interfaces.
 104      *
 105      * @return
 106      */
 107     private boolean serviceProvided(Class aRequired, Class[] aProvided) {
 108         for (Class provided : aProvided) {
 109             try {
 110                 provided = ReflectionUtils.wrapIfNeeded(provided);
 111                 aRequired = ReflectionUtils.wrapIfNeeded(aRequired);
 112                 provided.asSubclass(aRequired);
 113
 114                 return true;
 115             } catch (ClassCastException e) {
 116                 // No match, try the next one.
 117             }
 118         }
 119
 120         return false;
 121     }
 122
 123     @Override
 124     public ProvidedInterface getProvider() {
 125         return provider;
 126     }
 127
 128     @Override
 129     public void setProvider(ProvidedInterface aProvider) {
 130         assert aProvider != null;
 131         assert implementedBy(aProvider);
 132         provider = aProvider;
 133     }
 134
 135     @Override
 136     public boolean equals(Object aObject) {
 137         return this == aObject;
 138     }
 139
 140     @Override
 141     public boolean covers(RequiredInterface aObject) {
 142         // TODO do more than equals.
 143         if (!(aObject instanceof DefaultRequiredInterface)) {
 144             return false;
 145         }
 146
 147         DefaultRequiredInterface descr = (DefaultRequiredInterface) aObject;
 148
 149         if (required.length != descr.required.length) {
 150             return false;
 151         }
 152
 153         String[] interfaces1 = new String[required.length];
 154         String[] interfaces2 = new String[required.length];
 155
 156         for (int i = 0; i < required.length; i++) {
 157             interfaces1[i] = required[i].getName();
 158             interfaces2[i] = descr.required[i].getName();
 159         }
 160
 161         Arrays.sort(interfaces1);
 162         Arrays.sort(interfaces2);
 163
 164         return Arrays.equals(interfaces1, interfaces2);
 165     }
 166
 167     @Override
 168     public int hashCode() {
 169         return Arrays.hashCode(required);
 170     }
 171
 172     @Override
 173     public String toString() {
 174         StringBuffer buf = new StringBuffer();
 175         buf.append("." + getName() + ":");
 176
 177         for (Class intf : required) {
 178             buf.append("." + intf.getName());
 179         }
 180
 181         return buf.toString();
 182     }
 183 }