in utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/CommonAdaptorTypeCoercions.java [97:348]
public void registerStandardAdapters() {
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 Strings.isNonBlank(input) ? URI.create(input) : null;
}
});
registerAdapter(URI.class, String.class, new Function<URI,String>() {
@Override
public String apply(URI input) {
return input.toString();
}
});
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(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 checkValidForConversion(input, input.doubleValue());
}
});
registerAdapter(BigInteger.class, Long.class, new Function<BigInteger,Long>() {
@Override
public Long apply(BigInteger input) {
return input.longValueExact();
}
});
registerAdapter(BigInteger.class, Integer.class, new Function<BigInteger,Integer>() {
@Override
public Integer apply(BigInteger input) {
return input.intValueExact();
}
});
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, Instant.class, new Function<String,Instant>() {
@Override
public Instant apply(final String input) {
return Time.parseDate(input).toInstant();
}
});
registerAdapter(String.class, Timestamp.class, new Function<String,Timestamp>() {
@Override
public Timestamp apply(final String input) {
return new Timestamp(input);
}
});
registerAdapter(Date.class, Timestamp.class, new Function<Date,Timestamp>() {
@Override
public Timestamp apply(final Date input) {
return new Timestamp(input);
}
});
registerAdapter(Instant.class, Timestamp.class, new Function<Instant,Timestamp>() {
@Override
public Timestamp apply(final Instant input) {
return new Timestamp(input);
}
});
registerAdapter(String.class, QuorumCheck.class, new Function<String,QuorumCheck>() {
@Override
public QuorumCheck apply(final String input) {
return QuorumChecks.of(input);
}
});
registerAdapter(Integer.class, QuorumCheck.class, new Function<Integer,QuorumCheck>() {
@Override
public QuorumCheck apply(final Integer input) {
return QuorumChecks.of(input);
}
});
registerAdapter(Collection.class, QuorumCheck.class, new Function<Collection,QuorumCheck>() {
@Override
public QuorumCheck apply(final Collection input) {
return QuorumChecks.of(input);
}
});
registerAdapter(String.class, TimeZone.class, new Function<String,TimeZone>() {
@Override
public TimeZone apply(final String input) {
return TimeZone.getTimeZone(input);
}
});
registerAdapter(Long.class, Date.class, new Function<Long,Date>() {
@Override
public Date apply(final Long input) {
return new Date(input);
}
});
registerAdapter(Integer.class, Date.class, new Function<Integer,Date>() {
@Override
public Date apply(final Integer input) {
return new Date(input);
}
});
registerAdapter(String.class, Predicate.class, new Function<String,Predicate>() {
@Override
public Predicate apply(final String input) {
switch (input) {
case "alwaysFalse" : return Predicates.alwaysFalse();
case "alwaysTrue" : return Predicates.alwaysTrue();
case "isNull" : return Predicates.isNull();
case "notNull" : return Predicates.notNull();
default: throw new IllegalArgumentException("Cannot convert string '" + input + "' to predicate");
}
}
});
registerAdapter(String.class, Path.class, new Function<String,Path>() {
@Override
public Path apply(final String input) {
return Paths.get(input);
}
});
}