org.apache.camel.spi.TypeConverterRegistry Java Examples

@Override
public void load(TypeConverterRegistry registry) throws TypeConverterLoaderException {
    registry.addTypeConverter(
            MyPair.class,
            String.class,
            new SimpleTypeConverter(false, (type, exchange, value) -> MyPair.fromString((String) value)));
}
 

public RuntimeValue<CamelContext> createContext(
        RuntimeValue<Registry> registry,
        RuntimeValue<TypeConverterRegistry> typeConverterRegistry,
        RuntimeValue<ModelJAXBContextFactory> contextFactory,
        RuntimeValue<XMLRoutesDefinitionLoader> xmlLoader,
        RuntimeValue<ModelToXMLDumper> xmlModelDumper,
        RuntimeValue<FactoryFinderResolver> factoryFinderResolver,
        BeanContainer beanContainer,
        String version,
        CamelConfig config) {

    FastCamelContext context = new FastCamelContext(
            factoryFinderResolver.getValue(),
            version,
            xmlLoader.getValue(),
            xmlModelDumper.getValue());

    context.setDefaultExtension(RuntimeCamelCatalog.class, () -> new CamelRuntimeCatalog(config.runtimeCatalog));
    context.setRegistry(registry.getValue());
    context.setTypeConverterRegistry(typeConverterRegistry.getValue());
    context.setLoadTypeConverters(false);
    context.setModelJAXBContextFactory(contextFactory.getValue());
    context.build();
    context.addLifecycleStrategy(new CamelLifecycleEventBridge());
    context.getManagementStrategy().addEventNotifier(new CamelManagementEventBridge());

    // register to the container
    beanContainer.instance(CamelProducers.class).setContext(context);

    return new RuntimeValue<>(context);
}
 

public void addTypeConverterLoader(RuntimeValue<TypeConverterRegistry> registry,
        Class<? extends TypeConverterLoader> loader) {
    try {
        loader.getConstructor().newInstance().load(registry.getValue());
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@FallbackConverter
public static Object convertTo(Class<?> type, Exchange exchange, Object value, TypeConverterRegistry registry) {
    if (TimeZone.class.isAssignableFrom(value.getClass())) {
        return "Time talks";
    }
    return null;
}
 

public CamelTypeConverterRegistryBuildItem(RuntimeValue<TypeConverterRegistry> value) {
    this.value = value;
}
 

public RuntimeValue<TypeConverterRegistry> getRegistry() {
    return value;
}
 

public RuntimeValue<TypeConverterRegistry> createTypeConverterRegistry() {
    return new RuntimeValue<>(new FastTypeConverter());
}
 

public void addTypeConverterLoader(RuntimeValue<TypeConverterRegistry> registry, RuntimeValue<TypeConverterLoader> loader) {
    loader.getValue().load(registry.getValue());
}
 

@Override
public void load(TypeConverterRegistry registry) throws TypeConverterLoaderException {
    registerConverters(registry);
}
 

private void registerConverters(TypeConverterRegistry registry) {
    addTypeConverter(registry, org.apache.camel.component.knative.spi.CloudEvent.class, java.lang.String.class, false,
        (type, exchange, value) -> org.apache.camel.component.knative.spi.CloudEventTypeConverter.fromSpecVersion((java.lang.String) value));
}
 

private static void addTypeConverter(TypeConverterRegistry registry, Class<?> toType, Class<?> fromType, boolean allowNull, SimpleTypeConverter.ConversionMethod method) { 
    registry.addTypeConverter(toType, fromType, new SimpleTypeConverter(allowNull, method));
}
 

@Test
public void testRegistryContent() throws Exception {
    CamelContext camelctx = new DefaultCamelContext();
    TypeConverterRegistry registry = camelctx.getTypeConverterRegistry();
    Assert.assertTrue("More than 180 type converters", 180 <= registry.size());
}