in brooklyn-server/core/src/main/java/org/apache/brooklyn/util/core/flags/TypeCoercions.java [528:889]
public static void initStandardAdapters() {
registerAdapter(CharSequence.class, String.class, new Function<CharSequence,String>() {
@Override
public String apply(CharSequence input) {
return input.toString();
}
});
registerAdapter(byte[].class, String.class, new Function<byte[],String>() {
@Override
public String apply(byte[] input) {
return new String(input);
}
});
registerAdapter(Collection.class, Set.class, new Function<Collection,Set>() {
@SuppressWarnings("unchecked")
@Override
public Set apply(Collection input) {
return Sets.newLinkedHashSet(input);
}
});
registerAdapter(Collection.class, List.class, new Function<Collection,List>() {
@SuppressWarnings("unchecked")
@Override
public List apply(Collection input) {
return Lists.newArrayList(input);
}
});
registerAdapter(String.class, InetAddress.class, new Function<String,InetAddress>() {
@Override
public InetAddress apply(String input) {
return Networking.getInetAddressWithFixedName(input);
}
});
registerAdapter(String.class, HostAndPort.class, new Function<String,HostAndPort>() {
@Override
public HostAndPort apply(String input) {
return HostAndPort.fromString(input);
}
});
registerAdapter(String.class, UserAndHostAndPort.class, new Function<String,UserAndHostAndPort>() {
@Override
public UserAndHostAndPort apply(String input) {
return UserAndHostAndPort.fromString(input);
}
});
registerAdapter(String.class, Cidr.class, new Function<String,Cidr>() {
@Override
public Cidr apply(String input) {
return new Cidr(input);
}
});
registerAdapter(String.class, URL.class, new Function<String,URL>() {
@Override
public URL apply(String input) {
try {
return new URL(input);
} catch (Exception e) {
throw Exceptions.propagate(e);
}
}
});
registerAdapter(URL.class, String.class, new Function<URL,String>() {
@Override
public String apply(URL input) {
return input.toString();
}
});
registerAdapter(String.class, URI.class, new Function<String,URI>() {
@Override
public URI apply(String input) {
return URI.create(input);
}
});
registerAdapter(URI.class, String.class, new Function<URI,String>() {
@Override
public String apply(URI input) {
return input.toString();
}
});
registerAdapter(Closure.class, ConfigurableEntityFactory.class, new Function<Closure,ConfigurableEntityFactory>() {
@SuppressWarnings("unchecked")
@Override
public ConfigurableEntityFactory apply(Closure input) {
return new ClosureEntityFactory(input);
}
});
@SuppressWarnings({"unused", "deprecation"})
Function<?,?> ignoredVarHereToAllowSuppressDeprecationWarning1 = registerAdapter(org.apache.brooklyn.core.entity.factory.EntityFactory.class, ConfigurableEntityFactory.class, new Function<org.apache.brooklyn.core.entity.factory.EntityFactory,ConfigurableEntityFactory>() {
@SuppressWarnings("unchecked")
@Override
public ConfigurableEntityFactory apply(org.apache.brooklyn.core.entity.factory.EntityFactory input) {
if (input instanceof ConfigurableEntityFactory) return (ConfigurableEntityFactory)input;
return new ConfigurableEntityFactoryFromEntityFactory(input);
}
});
@SuppressWarnings({"unused", "deprecation"})
Function<?,?> ignoredVarHereToAllowSuppressDeprecationWarning2 = registerAdapter(Closure.class, org.apache.brooklyn.core.entity.factory.EntityFactory.class, new Function<Closure,org.apache.brooklyn.core.entity.factory.EntityFactory>() {
@SuppressWarnings("unchecked")
@Override
public org.apache.brooklyn.core.entity.factory.EntityFactory apply(Closure input) {
return new ClosureEntityFactory(input);
}
});
registerAdapter(Closure.class, Predicate.class, new Function<Closure,Predicate>() {
@Override
public Predicate<?> apply(final Closure closure) {
return new Predicate<Object>() {
@Override public boolean apply(Object input) {
return (Boolean) closure.call(input);
}
};
}
});
registerAdapter(Closure.class, Function.class, new Function<Closure,Function>() {
@Override
public Function apply(final Closure closure) {
return new Function() {
@Override public Object apply(Object input) {
return closure.call(input);
}
};
}
});
registerAdapter(Object.class, Duration.class, new Function<Object,Duration>() {
@Override
public Duration apply(final Object input) {
return org.apache.brooklyn.util.time.Duration.of(input);
}
});
registerAdapter(Object.class, TimeDuration.class, new Function<Object,TimeDuration>() {
@SuppressWarnings("deprecation")
@Override
public TimeDuration apply(final Object input) {
log.warn("deprecated automatic coercion of Object to TimeDuration (set breakpoint in TypeCoercions to inspect, convert to Duration)");
return JavaGroovyEquivalents.toTimeDuration(input);
}
});
registerAdapter(TimeDuration.class, Long.class, new Function<TimeDuration,Long>() {
@Override
public Long apply(final TimeDuration input) {
log.warn("deprecated automatic coercion of TimeDuration to Long (set breakpoint in TypeCoercions to inspect, use Duration instead of Long!)");
return input.toMilliseconds();
}
});
registerAdapter(Integer.class, AtomicLong.class, new Function<Integer,AtomicLong>() {
@Override public AtomicLong apply(final Integer input) {
return new AtomicLong(input);
}
});
registerAdapter(Long.class, AtomicLong.class, new Function<Long,AtomicLong>() {
@Override public AtomicLong apply(final Long input) {
return new AtomicLong(input);
}
});
registerAdapter(String.class, AtomicLong.class, new Function<String,AtomicLong>() {
@Override public AtomicLong apply(final String input) {
return new AtomicLong(Long.parseLong(input.trim()));
}
});
registerAdapter(Integer.class, AtomicInteger.class, new Function<Integer,AtomicInteger>() {
@Override public AtomicInteger apply(final Integer input) {
return new AtomicInteger(input);
}
});
registerAdapter(String.class, AtomicInteger.class, new Function<String,AtomicInteger>() {
@Override public AtomicInteger apply(final String input) {
return new AtomicInteger(Integer.parseInt(input.trim()));
}
});
/** This always returns a {@link Double}, cast as a {@link Number};
* however primitives and boxers get exact typing due to call in #stringToPrimitive */
registerAdapter(String.class, Number.class, new Function<String,Number>() {
@Override
public Number apply(String input) {
return Double.valueOf(input);
}
});
registerAdapter(BigDecimal.class, Double.class, new Function<BigDecimal,Double>() {
@Override
public Double apply(BigDecimal input) {
return input.doubleValue();
}
});
registerAdapter(BigInteger.class, Long.class, new Function<BigInteger,Long>() {
@Override
public Long apply(BigInteger input) {
return input.longValue();
}
});
registerAdapter(BigInteger.class, Integer.class, new Function<BigInteger,Integer>() {
@Override
public Integer apply(BigInteger input) {
return input.intValue();
}
});
registerAdapter(String.class, BigDecimal.class, new Function<String,BigDecimal>() {
@Override
public BigDecimal apply(String input) {
return new BigDecimal(input);
}
});
registerAdapter(Double.class, BigDecimal.class, new Function<Double,BigDecimal>() {
@Override
public BigDecimal apply(Double input) {
return BigDecimal.valueOf(input);
}
});
registerAdapter(String.class, BigInteger.class, new Function<String,BigInteger>() {
@Override
public BigInteger apply(String input) {
return new BigInteger(input);
}
});
registerAdapter(Long.class, BigInteger.class, new Function<Long,BigInteger>() {
@Override
public BigInteger apply(Long input) {
return BigInteger.valueOf(input);
}
});
registerAdapter(Integer.class, BigInteger.class, new Function<Integer,BigInteger>() {
@Override
public BigInteger apply(Integer input) {
return BigInteger.valueOf(input);
}
});
registerAdapter(String.class, Date.class, new Function<String,Date>() {
@Override
public Date apply(final String input) {
return Time.parseDate(input);
}
});
registerAdapter(String.class, Class.class, new Function<String,Class>() {
@Override
public Class apply(final String input) {
try {
return Class.forName(input);
} catch (ClassNotFoundException e) {
throw Exceptions.propagate(e);
}
}
});
registerAdapter(String.class, AttributeSensor.class, new Function<String,AttributeSensor>() {
@Override
public AttributeSensor apply(final String input) {
Entity entity = BrooklynTaskTags.getContextEntity(Tasks.current());
if (entity!=null) {
Sensor<?> result = entity.getEntityType().getSensor(input);
if (result instanceof AttributeSensor)
return (AttributeSensor) result;
}
return Sensors.newSensor(Object.class, input);
}
});
registerAdapter(String.class, Sensor.class, new Function<String,Sensor>() {
@Override
public AttributeSensor apply(final String input) {
Entity entity = BrooklynTaskTags.getContextEntity(Tasks.current());
if (entity!=null) {
Sensor<?> result = entity.getEntityType().getSensor(input);
if (result != null)
return (AttributeSensor) result;
}
return Sensors.newSensor(Object.class, input);
}
});
registerAdapter(String.class, List.class, new Function<String,List>() {
@Override
public List<String> apply(final String input) {
return JavaStringEscapes.unwrapJsonishListIfPossible(input);
}
});
registerAdapter(String.class, Set.class, new Function<String,Set>() {
@Override
public Set<String> apply(final String input) {
return MutableSet.copyOf(JavaStringEscapes.unwrapJsonishListIfPossible(input)).asUnmodifiable();
}
});
registerAdapter(String.class, QuorumCheck.class, new Function<String,QuorumCheck>() {
@Override
public QuorumCheck apply(final String input) {
return QuorumChecks.of(input);
}
});
registerAdapter(Iterable.class, String[].class, new Function<Iterable, String[]>() {
@Nullable
@Override
public String[] apply(@Nullable Iterable list) {
if (list == null) return null;
String[] result = new String[Iterables.size(list)];
int count = 0;
for (Object element : list) {
result[count++] = coerce(element, String.class);
}
return result;
}
});
registerAdapter(Iterable.class, Integer[].class, new Function<Iterable, Integer[]>() {
@Nullable
@Override
public Integer[] apply(@Nullable Iterable list) {
if (list == null) return null;
Integer[] result = new Integer[Iterables.size(list)];
int count = 0;
for (Object element : list) {
result[count++] = coerce(element, Integer.class);
}
return result;
}
});
registerAdapter(Iterable.class, int[].class, new Function<Iterable, int[]>() {
@Nullable
@Override
public int[] apply(@Nullable Iterable list) {
if (list == null) return null;
int[] result = new int[Iterables.size(list)];
int count = 0;
for (Object element : list) {
result[count++] = coerce(element, int.class);
}
return result;
}
});
registerAdapter(String.class, Map.class, new Function<String,Map>() {
@Override
public Map apply(final String input) {
Exception error = null;
// first try wrapping in braces if needed
if (!input.trim().startsWith("{")) {
try {
return apply("{ "+input+" }");
} catch (Exception e) {
Exceptions.propagateIfFatal(e);
// prefer this error
error = e;
// fall back to parsing without braces, e.g. if it's multiline
}
}
try {
return Yamls.getAs( Yamls.parseAll(input), Map.class );
} catch (Exception e) {
Exceptions.propagateIfFatal(e);
if (error!=null && input.indexOf('\n')==-1) {
// prefer the original error if it wasn't braced and wasn't multiline
e = error;
}
throw new IllegalArgumentException("Cannot parse string as map with flexible YAML parsing; "+
(e instanceof ClassCastException ? "yaml treats it as a string" :
(e instanceof IllegalArgumentException && Strings.isNonEmpty(e.getMessage())) ? e.getMessage() :
""+e) );
}
// NB: previously we supported this also, when we did json above;
// yaml support is better as it supports quotes (and better than json because it allows dropping quotes)
// snake-yaml, our parser, also accepts key=value -- although i'm not sure this is strictly yaml compliant;
// our tests will catch it if snake behaviour changes, and we can reinstate this
// (but note it doesn't do quotes; see http://code.google.com/p/guava-libraries/issues/detail?id=412 for that):
// return ImmutableMap.copyOf(Splitter.on(",").trimResults().omitEmptyStrings().withKeyValueSeparator("=").split(input));
}
});
}