lodsve.core.properties.env.PropertyConverter Maven / Gradle / Ivy
/*
* Copyright (C) 2018 Sun.Hao
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see elements = split((String) value, '_');
int size = elements.size();
boolean ok = size >= 1 && ((elements.get(0)).length() == 2 || (elements.get(0)).length() == 0);
if (ok) {
String language = elements.get(0);
String country = (size >= 2) ? elements.get(1) : "";
String variant = (size >= 3) ? elements.get(2) : "";
return new Locale(language, country, variant);
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a Locale");
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a Locale");
}
}
/**
* Split a string on the specified delimiter. To be removed when
* commons-lang has a better replacement available (Tokenizer?).
*
* todo: replace with a commons-lang equivalent
*
* @param s the string to split
* @param delimiter the delimiter
* @param trim a flag whether the single elements should be trimmed
* @return a list with the single tokens
*/
public static List split(String s, char delimiter, boolean trim) {
if (s == null) {
return new ArrayList();
}
List list = new ArrayList();
StringBuilder token = new StringBuilder();
int begin = 0;
boolean inEscape = false;
while (begin < s.length()) {
char c = s.charAt(begin);
if (inEscape) {
// last character was the escape marker
// can current character be escaped?
if (c != delimiter && c != LIST_ESC_CHAR) {
// no, also add escape character
token.append(LIST_ESC_CHAR);
}
token.append(c);
inEscape = false;
} else {
if (c == delimiter) {
// found a list delimiter -> add token and
// resetDefaultFileSystem buffer
String t = token.toString();
if (trim) {
t = t.trim();
}
list.add(t);
token = new StringBuilder();
} else if (c == LIST_ESC_CHAR) {
// eventually escape next character
inEscape = true;
} else {
token.append(c);
}
}
begin++;
}
// Trailing delimiter?
if (inEscape) {
token.append(LIST_ESC_CHAR);
}
// Add last token
String t = token.toString();
if (trim) {
t = t.trim();
}
list.add(t);
return list;
}
/**
* Split a string on the specified delimiter always trimming the elements.
* This is a shortcut for {@code split(s, delimiter, true)}.
*
* @param s the string to split
* @param delimiter the delimiter
* @return a list with the single tokens
*/
public static List split(String s, char delimiter) {
return split(s, delimiter, true);
}
/**
* Escapes the delimiters that might be contained in the given string. This
* method works like {@link #escapeListDelimiter(String, char)}. In
* addition, a single backslash will also be escaped.
*
* @param s the string with the value
* @param delimiter the list delimiter to use
* @return the correctly escaped string
*/
public static String escapeDelimiters(String s, char delimiter) {
String s1 = StringUtils.replace(s, LIST_ESCAPE, LIST_ESCAPE
+ LIST_ESCAPE);
return escapeListDelimiter(s1, delimiter);
}
/**
* Escapes the list delimiter if it is contained in the given string. This
* method ensures that list delimiter characters that are part of a
* property's value are correctly escaped when a configuration is saved to a
* file. Otherwise when loaded again the property will be treated as a list
* property.
*
* @param s the string with the value
* @param delimiter the list delimiter to use
* @return the escaped string
* @since 1.7
*/
public static String escapeListDelimiter(String s, char delimiter) {
return StringUtils.replace(s, String.valueOf(delimiter), LIST_ESCAPE
+ delimiter);
}
/**
* Convert the specified object into a Color. If the value is a String, the
* format allowed is (#)?[0-9A-F]{6}([0-9A-F]{2})?. Examples:
*
* - FF0000 (red)
* - 0000FFA0 (semi transparent blue)
* - #CCCCCC (gray)
* - #00FF00A0 (semi transparent green)
*
*
* @param value the value to convert
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to a Color
*/
public static Color toColor(Object value) throws ConversionException {
if (value instanceof Color) {
return (Color) value;
} else if (value instanceof String
&& !StringUtils.isBlank((String) value)) {
String color = ((String) value).trim();
int[] components = new int[3];
// check the size of the string
int minlength = components.length * 2;
if (color.length() < minlength) {
throw new ConversionException("The value " + value
+ " can't be converted to a Color");
}
// remove the leading #
if (color.startsWith("#")) {
color = color.substring(1);
}
try {
// parse the components
for (int i = 0; i < components.length; i++) {
components[i] = Integer.parseInt(
color.substring(2 * i, 2 * i + 2), HEX_RADIX);
}
// parse the transparency
int alpha;
if (color.length() >= minlength + 2) {
alpha = Integer.parseInt(
color.substring(minlength, minlength + 2),
HEX_RADIX);
} else {
alpha = Color.black.getAlpha();
}
return new Color(components[0], components[1], components[2],
alpha);
} catch (Exception e) {
throw new ConversionException("The value " + value
+ " can't be converted to a Color", e);
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a Color");
}
}
/**
* Convert the specified value into an internet address.
*
* @param value the value to convert
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to a InetAddress
* @since 1.5
*/
static InetAddress toInetAddress(Object value) throws ConversionException {
if (value instanceof InetAddress) {
return (InetAddress) value;
} else if (value instanceof String) {
try {
return InetAddress.getByName((String) value);
} catch (UnknownHostException e) {
throw new ConversionException("The value " + value
+ " can't be converted to a InetAddress", e);
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a InetAddress");
}
}
/**
* Convert the specified value into an email address.
*
* @param value the value to convert
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to an email address
* @since 1.5
*/
static Object toInternetAddress(Object value) throws ConversionException {
if (value.getClass().getName().equals(INTERNET_ADDRESS_CLASSNAME)) {
return value;
} else if (value instanceof String) {
try {
Constructor ctor = Class.forName(INTERNET_ADDRESS_CLASSNAME)
.getConstructor(new Class[]{String.class});
return ctor.newInstance(new Object[]{value});
} catch (Exception e) {
throw new ConversionException("The value " + value
+ " can't be converted to a InternetAddress", e);
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a InternetAddress");
}
}
/**
* Calls Class.isEnum() on Java 5, returns false on older JRE.
*/
static boolean isEnum(Class cls) {
return cls.isEnum();
}
/**
* Convert the specified value into a Java 5 enum.
*
* @param value the value to convert
* @param cls the type of the enumeration
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to an enumeration
* @since 1.5
*/
static > E toEnum(Object value, Class cls)
throws ConversionException {
if (value.getClass().equals(cls)) {
return cls.cast(value);
} else if (value instanceof String) {
try {
return Enum.valueOf(cls, (String) value);
} catch (Exception e) {
throw new ConversionException("The value " + value
+ " can't be converted to a " + cls.getName());
}
} else if (value instanceof Number) {
try {
E[] enumConstants = cls.getEnumConstants();
return enumConstants[((Number) value).intValue()];
} catch (Exception e) {
throw new ConversionException("The value " + value
+ " can't be converted to a " + cls.getName());
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a " + cls.getName());
}
}
/**
* Convert the specified object into a Date.
*
* @param value the value to convert
* @param format the DateFormat pattern to parse String values
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to a Calendar
*/
public static Date toDate(Object value, String format)
throws ConversionException {
if (value instanceof Date) {
return (Date) value;
} else if (value instanceof Calendar) {
return ((Calendar) value).getTime();
} else if (value instanceof String) {
try {
return new SimpleDateFormat(format).parse((String) value);
} catch (ParseException e) {
throw new ConversionException("The value " + value
+ " can't be converted to a Date", e);
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a Date");
}
}
/**
* Convert the specified object into a Calendar.
*
* @param value the value to convert
* @param format the DateFormat pattern to parse String values
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to a Calendar
*/
public static Calendar toCalendar(Object value, String format)
throws ConversionException {
if (value instanceof Calendar) {
return (Calendar) value;
} else if (value instanceof Date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime((Date) value);
return calendar;
} else if (value instanceof String) {
try {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new SimpleDateFormat(format)
.parse((String) value));
return calendar;
} catch (ParseException e) {
throw new ConversionException("The value " + value
+ " can't be converted to a Calendar", e);
}
} else {
throw new ConversionException("The value " + value
+ " can't be converted to a Calendar");
}
}
/**
* Returns an iterator over the simple values of a composite value. This
* implementation calls {@link #flatten(Object, char)} and returns an
* iterator over the returned collection.
*
* @param value the value to "split"
* @param delimiter the delimiter for String values
* @return an iterator for accessing the single values
*/
public static Iterator toIterator(Object value, char delimiter) {
return flatten(value, delimiter).iterator();
}
/**
* Returns a collection with all values contained in the specified object.
* This method is used for instance by the {@code addProperty()}
* implementation of the default configurations to gather all values of the
* property to add. Depending on the type of the passed in object the
* following things happen:
*
* - Strings are checked for delimiter characters and split if necessary.
* - For objects implementing the {@code Iterable} interface, the
* corresponding {@code Iterator} is obtained, and contained elements are
* added to the resulting collection.
* - Arrays are treated as {@code Iterable} objects.
* - All other types are directly inserted.
* - Recursive combinations are supported, e.g. a collection containing an
* array that contains strings: The resulting collection will only contain
* primitive objects (hence the name "flatten").
*
*
* @param value the value to be processed
* @param delimiter the delimiter for String values
* @return a "flat" collection containing all primitive values of
* the passed in object
*/
private static Collection flatten(Object value, char delimiter) {
if (value instanceof String) {
String s = (String) value;
if (s.indexOf(delimiter) > 0) {
return split(s, delimiter);
}
}
Collection