Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.util;
 
 import java.util.List;
 
 public class Reflect {
     public static String resourceName(Class<?> clazz) {
         return "/" + clazz.getName().replace('.''/') + ".class";        
     }
     
     public static String importName(Class<?> clazz) {
         String name;
 
         name = clazz.getName();
         return name.replace('$''.');
     }
 
     private static final List<?> PRIMITIVE_TYPES = Arrays.asList(
     );
     
     private static final List<?> WRAPPER_TYPES = Arrays.asList(
         Void.classBoolean.classByte.classCharacter.classInteger.classLong.classFloat.classDouble.class
     );
     
     public static Class<?> getWrapper(Class<?> primitive) {
         int idx;
 
         idx = .indexOf(primitive);
         if (idx == -1) {
             return null;
         } else {
             return (Class<?>) .get(idx);
         }
     }
 
     public static Class<?> getPrimitive(Class<?> wrapper) {
         int idx;
 
         idx = .indexOf(wrapper);
         if (idx == -1) {
             return null;
         } else {
             return (Class<?>) .get(idx);
         }
     }
 
     public static String getSimpleName(Class<?> cls) {
         String name;
         int idx;
 
         name = Reflect.importName(cls);
         idx = name.lastIndexOf('.');
         return name.substring(idx + 1); // ok for -1 :-)
     }
 
     public static Method lookup(Class<?> taskString rawName) {
         return lookup(taskrawNamenew Class[] {});
     }
 
     public static Method lookup(Class<?> taskString rawNameClass<?> arg) {
         return lookup(taskrawNamenew Class[] { arg });
     }
 
     public static Method lookup(Class<?> taskString rawNameClass<?> ... args) {
         Method[] methods;
         int i;
         Method m;
         Method found;
 
         methods = task.getMethods();
         found = null;
         for (i = 0; i < methods.lengthi++) {
             m = methods[i];
             if (equals(argsm.getParameterTypes())
                     && m.getName().equalsIgnoreCase(rawName)) {
                 if (found != null) {
                     throw new IllegalArgumentException("duplicate method: " + rawName);
                 }
                 found = m;
            }
        }
        return found;
    }
    public static boolean equals(Class<?>[] leftClass<?>[] right) {
        int i;
        if (left.length != right.length) {
            return false;
        }
        for (i = 0; i < left.lengthi++) {
            if (!left[i].equals(right[i])) {
                return false;
            }
        }
        return true;
    }
    
    //--
    
    public static <T extends Enum<?>> T[] getValues(Class<T> clazz) {
        Method m;
        
        try {
            m = clazz.getDeclaredMethod("values");
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
        m.setAccessible(true);
        try {
            return (T[]) m.invoke(null);
        } catch (IllegalArgumentException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
    
    public static boolean matches(Class<?>[] formalsObject[] actuals) {
        int max;
        Class<?> formal;
        Object actual;
        max = formals.length;
        if (actuals.length != max) {
            return false;
        }
        for (int i = 0; i < maxi++) {
            formal = formals[i];
            actual = actuals[i];
            if (!formal.isInstance(actual)) {
                if (formal.isPrimitive()) {
                    formal = Reflect.getWrapper(formal);
                    if (!formal.isInstance(actual)) {
                        return false;
                    }
                } else {
                    return false;
                }
            }
        }
        return true;
    }
New to GrepCode? Check out our FAQ X