/** * Convert a Map to a Map with keys and values of the desired types. If it is a Map and it is of * the same Map, Key and Value types it is returned as is, otherwise a new Map is created with all * keys and values converted to the desired type. If it is a String representation of a Map it is * converted to a Map. * * @param <K> The key type. * @param <V> The value type. * @param <M> The Map type. * @param obj The Object to be converted. * @param mapType The desired Map type. * @param keyType The desired key type. * @param valueType The desired value type. * @param emptyIfNull Whether or not an empty Map should be returned if the Map could not be * converted. * @return The converted Collection. */ public <K, V, M extends Map<K, V>> M convertToMap( Object obj, Class<M> mapType, Class<K> keyType, Class<V> valueType, boolean emptyIfNull) { if (obj != null) { if (obj instanceof Map) { // If it's already a collection Map map = (Map) obj; Pair<Class<?>, Class<?>> cachedType = getCachedKeyValueTypes(map); // Look up the cached types if available, if they can be downcast to the // requested types do so and update cache if (cachedType != null && keyType.isAssignableFrom(cachedType.getKey()) && valueType.isAssignableFrom(cachedType.getValue())) { setCacheKeyValueTypes(map, keyType, valueType); return (M) map; } else { return _convertContents(map, mapType, keyType, valueType); } } else { try { // If it's a string representation of key-value pairs M m = MapUtils.of(mapType); String string = convert(obj, String.class); if (string.startsWith("{") && string.endsWith("}")) { string = string.substring(1, string.length() - 1); } String[] entries = TextUtils.splitOnSpacesAndCommas(string); for (String str : entries) { String[] split = str.split("="); if (split.length == 2) { try { K k = convert(split[0], keyType); V v = convert(split[1], valueType); m.put(k, v); } catch (ConversionException ex) { } } } if (!m.isEmpty()) { return m; } } catch (ConversionException ex) { } } } if (emptyIfNull) { return MapUtils.of(mapType); } return null; }
/** * Initialize this PropertyHolder, loading and verifying it's properties. A PropertyHolder that * has not been initialized or whose initialization failed will throw an exception when accessed. * This method should be called only once, typically by the PropertyHolderRegistry that handles * PropertyHolders of this type before registration. * * @throws InitializationException if the PropertyHolder could not be initialized. */ public final void initialize() throws InitializationException { if (!isInitialized()) { try { verifyProperties(); _initialize(); initialized = true; } catch (PropertyValidationException ex) { throw new InitializationException(ex); } } else { throw new IllegalStateException( "Called initialize() on " + TextUtils.getTypeDescription(this) + " while already initialized."); } }
/** * Convert an Object to a Collection with elements of the desired type. If it is a Collection and * it is of the same collection and element type it is returned as is, otherwise a new Collection * is created with all elements converted to the desired type. If it is a String representation of * a Collection it is converted to a Collection. * * @param <E> The element type. * @param <C> The Collection type. * @param obj The Object to be converted. * @param collectionType The desired Collection type. * @param elementType The desired element type. * @param emptyIfNull Whether or not an empty Collection should be returned if the Collection * could not be converted. * @return The converted Collection. */ public <E, C extends Collection<E>> C convertToCollection( Object obj, Class<C> collectionType, Class<E> elementType, boolean emptyIfNull) { // Grab defaults for types if interfaces or non-datareference collections are provided Class<? extends C> constructionCollectionType; Class<? extends E> constructionElementType; if (collectionType.equals(List.class)) { if (DataReferencable.class.isAssignableFrom(elementType)) { constructionCollectionType = (Class) DataReferenceList.class; constructionElementType = (Class) DataReference.class; } else { constructionCollectionType = (Class) ArrayList.class; } } else if (collectionType.equals(Set.class)) { if (DataReferencable.class.isAssignableFrom(elementType)) { constructionElementType = (Class) DataReference.class; throw new IllegalArgumentException( "Set class is not supported for DataReferencable elements"); } constructionCollectionType = (Class) HashSet.class; } else { constructionCollectionType = collectionType; } if (obj != null) { if (obj instanceof Collection) { // If it's already a collection Collection collection = (Collection) obj; Class cachedElementType = getCachedElementType(collection); // If we have cached it's element type return if same if (cachedElementType != null && elementType.isAssignableFrom(cachedElementType) && collection.getClass().equals(constructionCollectionType)) { setCachedElementType(collection, elementType); return (C) collection; } else { return _convertContents(collection, constructionCollectionType, elementType); } } else { try { // If it's a single value convertable to E E e = convert(obj, elementType); C c = CollectionUtils.instanceOf(constructionCollectionType); c.add(e); return c; } catch (ConversionException ex) { } try { // If it's a string representation of one or many E's String string = convert(obj, String.class); String[] split = TextUtils.splitOnSpacesAndCommas(string); C c = CollectionUtils.instanceOf(constructionCollectionType); for (String str : split) { try { E e = convert(obj, elementType); c.add(e); } catch (ConversionException ex) { } } if (!c.isEmpty()) { return c; } } catch (ConversionException ex) { } } } // Fall through to here if a collection could not be converted for any reason if (emptyIfNull) { return CollectionUtils.instanceOf(constructionCollectionType); } else { return null; } }