Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  /*
   * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
   * subject to license terms.
   */ 
  
  package org.jdesktop.application;
  
 import java.net.URI;
 import java.net.URL;
 import java.util.List;

A base class for converting arbitrary types to and from Strings, as well as a registry of ResourceConverter implementations.

The supportsType method defines what types a ResourceConverter supports. By default it returns true for classes that are equal to the constructor's type argument. The parseType methods converts a string the ResourceConverter's supported type, and the toString does the inverse, it converts a supported type to a String. Concrete ResourceConverter subclasses must override parseType() and, in most cases, the toString method as well.

This class maintains a registry of ResourceConverters. The forType method returns the first ResourceConverter that supports a particular type, new ResourceConverters can be added with register(). A small set of generic ResourceConverters are registered by default. They support the following types:

  • Boolean
  • Integer
  • Float
  • Double
  • Long
  • Short
  • Byte
  • MessageFormat
  • URL
  • URI

The Boolean ResourceConverter returns true for "true", "on", "yes", false otherwise. The other primitive type ResourceConverters rely on the corresponding static parseType method, e.g. Integer.parseInt(). The MessageFormat ResourceConverter just creates MessageFormat object with the string as its constructor argument. The URL/URI converters just apply the corresponding constructor to the resource string.

Author(s):
Hans Muller (Hans.Muller@Sun.COM)
See also:
ResourceMap
 
 public abstract class ResourceConverter {
 
     protected final Class type;
 
     public abstract Object parseString(String sResourceMap r
 
     public String toString(Object obj) {
 	return (obj == null) ? "null" : obj.toString();
     }
 
     protected ResourceConverter(Class type) {
 	if (type == null) {
 	    throw new IllegalArgumentException("null type");
 	}
 	this. = type
     }
     private ResourceConverter() {  = null; }  // not used
 
     public boolean supportsType(Class testType) {
 	return .equals(testType);
     }
 
     public static class ResourceConverterException extends Exception {
 	private final String badString;
 	private String maybeShorten(String s) {
 	    int n = s.length();
 	    return (n < 128) ? s : s.substring(0, 128) + "...[" + (n-128) + " more characters]";
 	}
 
 	public ResourceConverterException(String messageString badStringThrowable cause) {
 	    super(messagecause);
 	    this. = maybeShorten(badString);
 	}
 
 	public ResourceConverterException(String messageString badString) {
 	    super(message);
 	    this. = maybeShorten(badString);
 	}
 
 	public String toString() {
	    StringBuffer sb = new StringBuffer(super.toString());
	    sb.append(" string: \"");
	    sb.append();
	    sb.append("\"");
	    return sb.toString();
	}
    }
    public static void register(ResourceConverter resourceConverter) {
	if (resourceConverter == null) {
	    throw new IllegalArgumentException("null resourceConverter");
	}
	.add(resourceConverter);
    }
    public static ResourceConverter forType(Class type) {
	if (type == null) {
	    throw new IllegalArgumentException("null type");
	}
        for (ResourceConverter sc) {
            if (sc.supportsType(type)) {
                return sc;
            }
        }
	return null;
    }
    private static ResourceConverter[] resourceConvertersArray = {
	new BooleanResourceConverter("true""on""yes"),
    };
    private static List<ResourceConverterresourceConverters = 
    private static class BooleanResourceConverter extends ResourceConverter {
	private final String[] trueStrings;
	BooleanResourceConverter(String ... trueStrings) {
	    super(Boolean.class);
	    this. = trueStrings;
	}
	public Object parseString(String sResourceMap ignore) {
	    s = s.trim();
	    for(String trueString : ) {
		if (s.equalsIgnoreCase(trueString)) {
		    return .;
		}
	    }
	    return .;
	}
	public boolean supportsType(Class testType) {
	    return testType.equals(Boolean.class) || testType.equals(boolean.class);
	}
    }
    private static abstract class NumberResourceConverter extends ResourceConverter {
	private final Class primitiveType;
	NumberResourceConverter(Class typeClass primitiveType) {
	    super(type);
	    this. = primitiveType;
	}
	protected abstract Number parseString(String sthrows NumberFormatException;
	    try {
		return parseString(s);
	    } 
	    catch (NumberFormatException e) {
		throw new ResourceConverterException("invalid " + .getSimpleName(), se);
	    }
	}
	public boolean supportsType(Class testType) {
	    return testType.equals() || testType.equals();
	}
    }
    private static class FloatResourceConverter extends NumberResourceConverter {
	    super(Float.classfloat.class);
	}
	protected Number parseString(String sthrows NumberFormatException {
	    return Float.parseFloat(s);
	}
    }
    private static class DoubleResourceConverter extends NumberResourceConverter {
	    super(Double.classdouble.class);
	}
	protected Number parseString(String sthrows NumberFormatException {
	    return Double.parseDouble(s);
	}
    }
    private static abstract class INumberResourceConverter extends ResourceConverter {
	private final Class primitiveType;
	INumberResourceConverter(Class typeClass primitiveType) {
	    super(type);
	    this. = primitiveType;
	}
	protected abstract Number parseString(String sint radixthrows NumberFormatException;
	    try {
                String[] nar = s.split("&"); // number ampersand radix
                int radix = (nar.length == 2) ? Integer.parseInt(nar[1]) : -1;
                return parseString(nar[0], radix);
            }
	    catch (NumberFormatException e) {
		throw new ResourceConverterException("invalid " + .getSimpleName(), se);
	    }
        }
	public boolean supportsType(Class testType) {
	    return testType.equals() || testType.equals();
	}
    }
    private static class ByteResourceConverter extends INumberResourceConverter {
	    super(Byte.classbyte.class);
	}
        protected Number parseString(String sint radixthrows NumberFormatException {
	    return (radix == -1) ? Byte.decode(s) : Byte.parseByte(sradix);
	}
    }
    private static class IntegerResourceConverter extends INumberResourceConverter {
	    super(Integer.classint.class);
	}
        protected Number parseString(String sint radixthrows NumberFormatException {
	    return (radix == -1) ? Integer.decode(s) : Integer.parseInt(sradix);
	}
    }
    private static class LongResourceConverter extends INumberResourceConverter {
	    super(Long.classlong.class);
	}
        protected Number parseString(String sint radixthrows NumberFormatException {
	    return (radix == -1) ? Long.decode(s) : Long.parseLong(sradix);
	}
    }
    private static class ShortResourceConverter extends INumberResourceConverter {
        ShortResourceConverter() {
	    super(Short.classshort.class);
	}
        protected Number parseString(String sint radixthrows NumberFormatException {
	    return (radix == -1) ? Short.decode(s) : Short.parseShort(sradix);
	}
    }
    private static class MessageFormatResourceConverter extends ResourceConverter {
	    super(MessageFormat.class);
	}
	public Object parseString(String sResourceMap ignore) {
	    return new MessageFormat(s);
	}
    }
    private static class URLResourceConverter extends ResourceConverter {
	    super(URL.class);
	}
            try {
                return new URL(s);
            }
            catch(MalformedURLException e) {
		throw new ResourceConverterException("invalid URL"se);
            }
	}
    }
    private static class URIResourceConverter extends ResourceConverter {
	    super(URI.class);
	}
            try {
                return new URI(s);
            }
            catch(URISyntaxException e) {
		throw new ResourceConverterException("invalid URI"se);
            }
	}
    }
New to GrepCode? Check out our FAQ X