Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.skife.config;
  
  import java.net.URI;
  import java.util.HashMap;
  import java.util.Map;
 
 final class DefaultCoercibles
 {
 
     private DefaultCoercibles()
     {
     }
 
     public static final Coercible<?> CASE_INSENSITIVE_ENUM_COERCIBLE = new CaseInsensitiveEnumCoercible();
 
     static final Coercible<BooleanBOOLEAN_COERCIBLE = new Coercible<Boolean>() {
         public Coercer<Booleanaccept(final Class<?> clazz) {
             if (Boolean.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<ByteBYTE_COERCIBLE = new Coercible<Byte>() {
         public Coercer<Byteaccept(final Class<?> clazz) {
             if (Byte.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<ShortSHORT_COERCIBLE = new Coercible<Short>() {
         public Coercer<Shortaccept(final Class<?> clazz) {
             if (Short.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<IntegerINTEGER_COERCIBLE = new Coercible<Integer>() {
         public Coercer<Integeraccept(final Class<?> clazz) {
             if (Integer.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<LongLONG_COERCIBLE = new Coercible<Long>() {
         public Coercer<Longaccept(final Class<?> clazz) {
             if (Long.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<FloatFLOAT_COERCIBLE = new Coercible<Float>() {
         public Coercer<Floataccept(final Class<?> clazz) {
             if (Float.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<DoubleDOUBLE_COERCIBLE = new Coercible<Double>() {
         public Coercer<Doubleaccept(final Class<?> clazz) {
             if (Double.class.isAssignableFrom(clazz) || ..isAssignableFrom(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<StringSTRING_COERCIBLE = new Coercible<String>() {
         public Coercer<Stringaccept(final Class<?> clazz) {
             if (String.class.equals(clazz)) {
                 return .;
             }
             return null;
         }
     };
 
     static final Coercible<URIURI_COERCIBLE = new Coercible<URI>() {
         public Coercer<URIaccept(final Class<?> clazz) {
             if (URI.class.equals(clazz)) {
                 return .;
             }
             return null;
         }
     };

    
A Coercible that accepts any type with a static valueOf(String) method.
    static final Coercible<?> VALUE_OF_COERCIBLE = new Coercible<Object>() {
        private Map<Class<?>, Coercer<Object>> coercerMap = new HashMap<Class<?>, Coercer<Object>>();
        public Coercer<Objectaccept(final Class<?> type)
        {
            if (.containsKey(type)) {
                // If a key exists, the value always gets returned. If a null value is in the map,
                // the type was seen before and deemed not worthy.
                return .get(type);
            }
            Coercer<Objectcoercer = null;
            try {
                // Method must be 'static valueOf(String)' and return the type in question.
                Method candidate = type.getMethod("valueOf"String.class);
                if (!Modifier.isStatic(candidate.getModifiers())) {
                    // not static.
                    candidate = null;
                }
                else if (!candidate.getReturnType().isAssignableFrom(type)) {
                    // does not return the right type.
                    candidate = null;
                }
                if (candidate != null) {
                    final Method valueOfMethod = candidate;
                    coercer = new Coercer<Object>() {
                        public Object coerce(final String value)
                        {
                            try {
                                return value == null ? null : valueOfMethod.invoke(nullvalue);
                            }
                            catch (Exception e) {
                                throw convertException(e);
                            }
                        }
                    };
                }
            }
            catch(NoSuchMethodException nsme) {
                // Don't do anything, the class does not have a method.
            }
            .put(typecoercer);
            return coercer;
        }
    };

    
A Coercible that accepts any type with a c'tor that takes a single string parameter.
    static final Coercible<?> STRING_CTOR_COERCIBLE = new Coercible<Object>() {
        private Map<Class<?>, Coercer<Object>> coercerMap = new HashMap<Class<?>, Coercer<Object>>();
        public Coercer<Objectaccept(final Class<?> type)
        {
            if (.containsKey(type)) {
                // If a key exists, the value always gets returned. If a null value is in the map,
                // the type was seen before and deemed not worthy.
                return .get(type);
            }
            Coercer<Objectcoercer = null;
            try {
                final Constructor<?> ctor = type.getConstructor(String.class);
                coercer = new Coercer<Object>() {
                    public Object coerce(final String value)
                    {
                        try {
                            return value == null ? null : ctor.newInstance(value);
                        }
                        catch (Exception e) {
                            throw convertException(e);
                        }
                    }
                };
            }
            catch(NoSuchMethodException nsme) {
                // Don't do anything, the class does not have a matching c'tor
            }
            .put(typecoercer);
            return coercer;
        }
    };

    
A Coercible that accepts any type with a c'tor that takes a single Object parameter. This one was lovingly prepared and added for Jodatime DateTime objects.
    static final Coercible<?> OBJECT_CTOR_COERCIBLE = new Coercible<Object>() {
        private Map<Class<?>, Coercer<Object>> coercerMap = new HashMap<Class<?>, Coercer<Object>>();
        public Coercer<Objectaccept(final Class<?> type)
        {
            if (.containsKey(type)) {
                // If a key exists, the value always gets returned. If a null value is in the map,
                // the type was seen before and deemed not worthy.
                return .get(type);
            }
            Coercer<Objectcoercer = null;
            try {
                final Constructor<?> ctor = type.getConstructor(Object.class);
                coercer = new Coercer<Object>() {
                    public Object coerce(final String value)
                    {
                        try {
                            return ctor.newInstance(value);
                        }
                        catch (Exception e) {
                            throw convertException(e);
                        }
                    }
                };
            }
            catch(NoSuchMethodException nsme) {
                // Don't do anything, the class does not have a matching c'tor
            }
            .put(typecoercer);
            return coercer;
        }
    };
    static final Coercer<BooleanBOOLEAN_COERCER = new Coercer<Boolean>() {
        public Boolean coerce(final String value) {
            return value != null ? Boolean.valueOf(value) : null;
        }
    };
    static final Coercer<ByteBYTE_COERCER = new Coercer<Byte>() {
        public Byte coerce(final String value) {
            return value != null ? Byte.valueOf(value) : null;
        }
    };
    static final Coercer<ShortSHORT_COERCER = new Coercer<Short>() {
        public Short coerce(final String value) {
            return value != null ? Short.valueOf(value) : null;
        }
    };
    static final Coercer<IntegerINTEGER_COERCER = new Coercer<Integer>() {
        public Integer coerce(final String value) {
            return value != null ? Integer.valueOf(value) : null;
        }
    };
    static final Coercer<LongLONG_COERCER = new Coercer<Long>() {
        public Long coerce(final String value) {
            return value != null ? Long.valueOf(value) : null;
        }
    };
    static final Coercer<FloatFLOAT_COERCER = new Coercer<Float>() {
        public Float coerce(final String value) {
            return value != null ? Float.valueOf(value) : null;
        }
    };
    static final Coercer<DoubleDOUBLE_COERCER = new Coercer<Double>() {
        public Double coerce(final String value) {
            return value != null ? Double.valueOf(value) : null;
        }
    };
    static final Coercer<StringSTRING_COERCER = new Coercer<String>() {
        public String coerce(final String value) {
            return value;
        }
    };
    static final Coercer<URIURI_COERCER = new Coercer<URI>() {
        public URI coerce(final String value) {
            return value != null ? URI.create(value) : null;
        }
    };
    public static final RuntimeException convertException(final Throwable t)
    {
        if (t instanceof RuntimeException) {
            return (RuntimeExceptiont;
        }
        else if (t instanceof InvocationTargetException) {
            return convertException(((InvocationTargetException)t).getTargetException());
        }
        else {
            return new RuntimeException(t);
        }
    }
New to GrepCode? Check out our FAQ X