Java TypeConverter.mandatoryConvertTo方法代码示例

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
private static Object convert(TypeConverter typeConverter, Class<?> type, Object value)
    throws URISyntaxException, NoTypeConversionAvailableException {
    if (typeConverter != null) {
        return typeConverter.mandatoryConvertTo(type, value);
    }
    if (type == URI.class) {
        return new URI(value.toString());
    }
    PropertyEditor editor = PropertyEditorManager.findEditor(type);
    if (editor != null) {
        // property editor is not thread safe, so we need to lock
        Object answer;
        synchronized (LOCK) {
            editor.setAsText(value.toString());
            answer = editor.getValue();
        }
        return answer;
    }
    return null;
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
public <T> T getMandatoryBody(Class<T> type) throws InvalidPayloadException {
    // eager same instance type test to avoid the overhead of invoking the type converter
    // if already same type
    if (type.isInstance(body)) {
        return type.cast(body);
    }

    Exchange e = getExchange();
    if (e != null) {
        TypeConverter converter = e.getContext().getTypeConverter();
        try {
            return converter.mandatoryConvertTo(type, e, getBody());
        } catch (Exception cause) {
            throw new InvalidPayloadException(e, type, this, cause);
        }
    }
    throw new InvalidPayloadException(e, type, this);
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
private static long extractOffset(String now, TypeConverter typeConverter) throws NoTypeConversionAvailableException {
    Matcher matcher = NOW_PATTERN.matcher(now);
    if (matcher.matches()) {
        String op = matcher.group(1);
        String remainder = matcher.group(2);

        // convert remainder to a time millis (eg we have a String -> long converter that supports
        // syntax with hours, days, minutes: eg 5h30m for 5 hours and 30 minutes).
        long offset = typeConverter.mandatoryConvertTo(long.class, remainder);

        if ("+".equals(op)) {
            return offset;
        } else {
            return -1 * offset;
        }
    }

    return 0;
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
private String asBeanParameter(TypeConverter converter, Map.Entry<String, Object> entry) {
    try {
        return "bean." + entry.getKey() + "=" + converter.mandatoryConvertTo(String.class, entry.getValue());
    } catch (NoTypeConversionAvailableException e) {
        throw new IllegalStateException(e);
    }
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
private <T> void consumeOption(String name, Class<T> type, Consumer<T> consumer) throws NoTypeConversionAvailableException {
    final TypeConverter converter = getCamelContext().getTypeConverter();
    final Object val = getOptions().get(name);
    final T result = converter.mandatoryConvertTo(type, val);

    consumer.accept(result);

    LOGGER.debug("Consume option {}", name);
    getOptions().remove(name);
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
/**
 * Converts the value to the given expected type or throws an exception
 *
 * @return the converted value
 * @throws TypeConversionException is thrown if error during type conversion
 * @throws NoTypeConversionAvailableException} if no type converters exists to convert to the given type
 */
public static <T> T convertToMandatoryType(Exchange exchange, Class<T> type, Object value)
    throws TypeConversionException, NoTypeConversionAvailableException {
    CamelContext camelContext = exchange.getContext();
    ObjectHelper.notNull(camelContext, "CamelContext of Exchange");
    TypeConverter converter = camelContext.getTypeConverter();
    if (converter != null) {
        return converter.mandatoryConvertTo(type, exchange, value);
    }
    throw new NoTypeConversionAvailableException(value, type);
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
private List<DBObject> attemptConvertToList(List insertList, Exchange exchange) throws CamelMongoDbException {
    List<DBObject> dbObjectList = new ArrayList<DBObject>(insertList.size());
    TypeConverter converter = exchange.getContext().getTypeConverter();
    for (Object item : insertList) {
        try {
            DBObject dbObject = converter.mandatoryConvertTo(DBObject.class, item);
            dbObjectList.add(dbObject);
        } catch (Exception e) {
            throw new CamelMongoDbException("MongoDB operation = insert, Assuming List variant of MongoDB insert operation, but List contains non-DBObject items", e);
        }
    }
    return dbObjectList;
}
 

import org.apache.camel.TypeConverter; //导入方法依赖的package包/类
@Test
public void convertWithTypeConverter(TypeConverter converter) throws NoTypeConversionAvailableException {
    TypeConverterInput input = new TypeConverterInput();
    input.setProperty("property value is [{{property2}}]");

    TypeConverterOutput output = converter.mandatoryConvertTo(TypeConverterOutput.class, input);

    assertThat(output.getProperty(), is(equalTo("property value is [value 2]")));
}