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); } } }
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; }
public List<?> convert(CamelContext camelContext, List<?> values, Class[] targetTypes) { LOG.debug("About to convert those arguments: {}", values); List<Object> convertedArguments = new ArrayList<>(values.size()); for (int i = 0; i < values.size(); i++) { try { convertedArguments.add(camelContext.getTypeConverter().mandatoryConvertTo(targetTypes[i], values.get(i))); } catch (NoTypeConversionAvailableException e) { LOG.debug("Failed to convert {} to type {}. Falling back to Jackson conversion.", values.get(i), targetTypes[i]); convertedArguments.add(objectMapper.convertValue(values.get(i), targetTypes[i])); } } LOG.debug("Converted arguments: {}", convertedArguments); return convertedArguments; }
public void marshal(Exchange exchange, Object graph, OutputStream stream) throws Exception { byte[] bytes = exchange.getContext().getTypeConverter().mandatoryConvertTo(byte[].class, graph); String body = reverseBytes(bytes); stream.write(body.getBytes()); }
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); }
@SuppressWarnings("rawtypes") private List<DBObject> attemptConvertToList(List insertList, Exchange exchange) throws CamelMongoDbException { List<DBObject> dbObjectList = new ArrayList<>(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; }
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); } }
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); } }
private void doRun(final Exchange exchange, final AsyncCallback callback, IgniteCompute compute) throws Exception { Object job = exchange.getIn().getBody(); if (Collection.class.isAssignableFrom(job.getClass())) { Collection<?> col = (Collection<?>) job; TypeConverter tc = exchange.getContext().getTypeConverter(); Collection<IgniteRunnable> runnables = new ArrayList<>(col.size()); for (Object o : col) { runnables.add(tc.mandatoryConvertTo(IgniteRunnable.class, o)); } compute.run(runnables); } else if (IgniteRunnable.class.isAssignableFrom(job.getClass())) { compute.run((IgniteRunnable) job); } else { throw new RuntimeCamelException(String.format( "Ignite Compute endpoint with RUN executionType is only " + "supported for IgniteRunnable payloads, or collections of them. The payload type was: %s.", job.getClass().getName())); } }
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); }
@Lazy @Bean(name = "service-discovery") public CamelCloudServiceDiscovery serviceDiscovery(List<ServiceDiscovery> serviceDiscoveryList) throws NoTypeConversionAvailableException { String cacheTimeout = configurationProperties.getServiceDiscovery().getCacheTimeout(); Long timeout = null; if (cacheTimeout != null) { timeout = camelContext.getTypeConverter().mandatoryConvertTo(Long.class, timeout); } return new CamelCloudServiceDiscovery(timeout, serviceDiscoveryList); }
private boolean processInBody(Exchange exchange, Map<String, Object> properties) { final String inBodyProperty = endpoint.getInBody(); if (inBodyProperty != null) { Object value = exchange.getIn().getBody(); try { value = getEndpoint().getCamelContext().getTypeConverter().mandatoryConvertTo( FacebookEndpointConfiguration.class.getDeclaredField(inBodyProperty).getType(), exchange, value); } catch (Exception e) { exchange.setException(new RuntimeCamelException(String.format( "Error converting value %s to property %s: %s", value, inBodyProperty, e.getMessage()), e)); return false; } LOG.debug("Property [{}] has message body value {}", inBodyProperty, value); properties.put(inBodyProperty, value); } return true; }
/** * Resolve the query by loading the query from the classpath or file resource if needed. */ public static String resolveQuery(CamelContext camelContext, String query, String placeholder) throws NoTypeConversionAvailableException, IOException { String answer = query; if (ResourceHelper.hasScheme(query)) { InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(camelContext, query); answer = camelContext.getTypeConverter().mandatoryConvertTo(String.class, is); if (placeholder != null) { answer = answer.replaceAll(placeholder, "?"); } } return answer; } }
@Override protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception { EndpointType type = getCamelContext().getTypeConverter().mandatoryConvertTo(EndpointType.class, remaining); return new SparkEndpoint(uri, this, type); }
public Object unmarshal(Exchange exchange, InputStream stream) throws Exception { byte[] bytes = exchange.getContext().getTypeConverter().mandatoryConvertTo(byte[].class, stream); String body = reverseBytes(bytes); return body; }
@Override protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception { RmiEndpoint rmi = new RmiEndpoint(uri, this); // lookup remote interfaces List<Class<?>> classes = new ArrayList<>(); Iterator<?> it = getAndRemoveParameter(parameters, "remoteInterfaces", Iterator.class); while (it != null && it.hasNext()) { Object next = it.next(); Class<?> clazz = getCamelContext().getTypeConverter().mandatoryConvertTo(Class.class, next); classes.add(clazz); } if (!classes.isEmpty()) { List<Class<?>> interfaces = classes; rmi.setRemoteInterfaces(interfaces); } setProperties(rmi, parameters); return rmi; } }
public void index(Exchange exchange) throws Exception { LOG.debug("Indexing {}", exchange); openIndexWriter(); Map<String, Object> headers = exchange.getIn().getHeaders(); add("exchangeId", exchange.getExchangeId(), true); for (Entry<String, Object> entry : headers.entrySet()) { String field = entry.getKey(); String value = exchange.getContext().getTypeConverter().mandatoryConvertTo(String.class, entry.getValue()); add(field, value, true); } add("contents", exchange.getIn().getMandatoryBody(String.class), true); closeIndexWriter(); }
/** * Reads the message from a code. */ private String readImage(final Exchange exchange, final InputStream stream) throws Exception { final MultiFormatReader reader = new MultiFormatReader(); final BufferedInputStream in = exchange.getContext() .getTypeConverter() .mandatoryConvertTo(BufferedInputStream.class, stream); final BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(new BufferedImageLuminanceSource(ImageIO.read(in)))); final Result result = reader.decode(bitmap, readerHintMap); // write the found barcode format into the header exchange.getOut().setHeader(Barcode.BARCODE_FORMAT, result.getBarcodeFormat()); return result.getText(); }
@Override public void marshal(Exchange exchange, Object o, OutputStream outputStream) throws Exception { IBaseResource iBaseResource; if (!(o instanceof IBaseResource)) { iBaseResource = exchange.getContext().getTypeConverter().mandatoryConvertTo(IBaseResource.class, exchange, o); } else { iBaseResource = (IBaseResource) o; } IParser parser = getFhirContext().newXmlParser(); configureParser(parser); parser.encodeResourceToWriter(iBaseResource, new OutputStreamWriter(outputStream)); if (isContentTypeHeader()) { exchange.getMessage().setHeader(Exchange.CONTENT_TYPE, parser.getEncoding().getResourceContentTypeNonLegacy()); } }
@Override public void marshal(Exchange exchange, Object o, OutputStream outputStream) throws Exception { IBaseResource iBaseResource; if (!(o instanceof IBaseResource)) { iBaseResource = exchange.getContext().getTypeConverter().mandatoryConvertTo(IBaseResource.class, exchange, o); } else { iBaseResource = (IBaseResource) o; } IParser parser = getFhirContext().newJsonParser(); configureParser(parser); parser.encodeResourceToWriter(iBaseResource, new OutputStreamWriter(outputStream)); if (isContentTypeHeader()) { exchange.getMessage().setHeader(Exchange.CONTENT_TYPE, parser.getEncoding().getResourceContentTypeNonLegacy()); } }