jmultimethod

Multimethod.java (5166B)

---

 // Copyright (c) 2009, 2015 Tomas Hlavaty All rights reserved.
 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 
 // Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following
 // disclaimer. Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following
 // disclaimer in the documentation and/or other materials provided
 // with the distribution.
 
 // Neither the name of jmultimethod nor the names of its contributors
 // may be used to endorse or promote products derived from this
 // software without specific prior written permission.
 
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 // COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
 package jmultimethod;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 
 public class Multimethod {
 
     protected String name;
     protected final ArrayList<Method> methods = new ArrayList<Method>();
     protected final MethodComparator methodComparator = new MethodComparator();
 
     public Multimethod(String name, Class... classes) {
         this.name = name;
         for(Class c: classes) {
             add(c);
         }
     }
 
     public void add(Class c) {
         for(Method m: c.getMethods()) {
             for(Annotation ma: m.getAnnotations()) {
                 if(ma instanceof Multi) {
                     Multi g = (Multi) ma;
                     if(this.name.equals(g.value())) {
                         methods.add(m);
                     }
                 }
             }
         }
         sort();
     }
 
     protected void sort() {
         Method[] a = new Method[methods.size()];
         methods.toArray(a);
         Arrays.sort(a, methodComparator);
         methods.clear();
         for(Method m: a) {
             methods.add(m);
         }
     }
 
     protected class MethodComparator implements Comparator<Method> {
         @Override
         public int compare(Method l, Method r) {
             if(l.equals(r)) {
                 return 0;
             }
             // most specific methods first
             Class[] lc = l.getParameterTypes();
             Class[] rc = r.getParameterTypes();
             for(int i = 0; i < lc.length; i++) {
                 String lv = value(l, i);
                 String rv = value(r, i);
                 if(lv == null) {
                     if(rv == null) {
                         if(lc[i].isAssignableFrom(rc[i])) {
                             return 1;
                         }
                     } else {
                         return 1;
                     }
                 } else {
                     if(rv == null) {
                         return -1;
                     }
                 }
             }
             return -1;
         }
     }
 
     protected String value(Method method, int arg) {
         Annotation[] a = method.getParameterAnnotations()[arg];
         for(Annotation p: a) {
             if(p instanceof V) {
                 V v = (V) p;
                 return v.value();
             }
         }
         return null;
     }
 
     protected boolean isApplicable(Method method, Object... args) {
         Class[] c = method.getParameterTypes();
         for(int i = 0; i < c.length; i++) {
             // must be instanceof and equal to annotated value if present
             if(c[i].isInstance(args[i])) {
                 String v = value(method, i);
                 if(v != null && !v.equals(args[i])) {
                     return false;
                 }
             } else {
                 if(args[i] != null || !Object.class.equals(c[i])) {
                     return false;
                 }
             }
         }
         return true;
     }
 
     public Object invoke(Object self, Object... args) {
         Method m = null; // first applicable method (most specific)
         for(Method method: methods) {
             if(isApplicable(method, args)) {
                 m = method;
                 break;
             }
         }
         if(m == null) {
             throw new RuntimeException("No applicable method '" + name + "'.");
         }
         try {
             return m.invoke(self, args);
         } catch (Exception e) {
             throw new RuntimeException("Method invocation failed '" + name + "'.");
         }
     }
 }