Refine search
public <T> T evaluate(Exchange exchange, Class<T> tClass) { try { Expression expression = parseExpression(); EvaluationContext evaluationContext = createEvaluationContext(exchange); Object value = expression.getValue(evaluationContext); // Let Camel handle the type conversion return exchange.getContext().getTypeConverter().convertTo(tClass, value); } catch (Exception e) { throw new ExpressionEvaluationException(this, exchange, e); } }
@Override public T onRdd(JavaRDDLike rdd, Object... payloads) { if (payloads.length != payloadsTypes.length) { String message = format("Received %d payloads, but expected %d.", payloads.length, payloadsTypes.length); throw new IllegalArgumentException(message); } for (int i = 0; i < payloads.length; i++) { payloads[i] = camelContext.getTypeConverter().convertTo(payloadsTypes[i], payloads[i]); } return doOnRdd(rdd, payloads); }
@Converter public static InputStream toInputStream(Response response, Exchange exchange) { Object obj = response.getEntity(); if (obj == null) { return null; } if (obj instanceof InputStream) { // short circuit the lookup return (InputStream)obj; } TypeConverterRegistry registry = exchange.getContext().getTypeConverterRegistry(); TypeConverter tc = registry.lookup(InputStream.class, obj.getClass()); if (tc != null) { return tc.convertTo(InputStream.class, exchange, obj); } return null; }
private static String asString(Exchange exchange, Object value) { return exchange.getContext().getTypeConverter().convertTo(String.class, exchange, value); }
/** * Extract an Exception from the exchange. This method will always return a * * @param exchange the Camel exchange * @return an exception */ public Exception extractException(Exchange exchange) { Exception e = exchange.getException(); if (e == null || convertExceptions) { e = context.getTypeConverter().convertTo(FaultException.class, exchange); } return e; }
private OutputStream resolveStreamFromHeader(Object o, Exchange exchange) throws CamelExchangeException { return exchange.getContext().getTypeConverter().convertTo(OutputStream.class, o); }
public TwitterTimelineEndpoint(String uri, String remaining, String user, TwitterTimelineComponent component, TwitterConfiguration properties) { super(uri, component, properties); if (remaining == null) { throw new IllegalArgumentException(String.format("The timeline type must be specified for '%s'", uri)); } this.timelineType = component.getCamelContext().getTypeConverter().convertTo(TimelineType.class, remaining); this.user = user; }
@Override public <T> T evaluate(Exchange exchange, Class<T> type) { Object result = evaluate(exchange); return exchange.getContext().getTypeConverter().convertTo(type, exchange, result); } }
public TwitterStreamingEndpoint(String uri, String remaining, String keywords, TwitterStreamingComponent component, TwitterConfiguration properties) { super(uri, component, properties); if (remaining == null) { throw new IllegalArgumentException(String.format("The streaming type must be specified for '%s'", uri)); } this.streamingType = component.getCamelContext().getTypeConverter().convertTo(StreamingType.class, remaining); this.keywords = keywords; }
@Override public <T> T evaluate(Exchange exchange, Class<T> type) { Object result = evaluate(exchange); return exchange.getContext().getTypeConverter().convertTo(type, exchange, result); }
@Override public Object onRdd(JavaRDDLike rdd, Object... payloads) { try { List<Object> arguments = new ArrayList<>(payloads.length + 1); arguments.add(rdd); arguments.addAll(asList(payloads)); if (arguments.get(1) == null) { arguments.remove(1); } Method callbackMethod = rddCallbacks.get(0); callbackMethod.setAccessible(true); if (camelContext != null) { for (int i = 1; i < arguments.size(); i++) { arguments.set(i, camelContext.getTypeConverter().convertTo(callbackMethod.getParameterTypes()[i], arguments.get(i))); } } return callbackMethod.invoke(objectWithCallback, arguments.toArray(new Object[arguments.size()])); } catch (IllegalAccessException | InvocationTargetException e) { throw new RuntimeException(e); } }
@Override public <T> T evaluate(Exchange exchange, Class<T> type) { Object result = evaluate(exchange); return exchange.getContext().getTypeConverter().convertTo(type, exchange, result); } }
private GeoApiContext.Builder configureProxyAuth(GeoApiContext.Builder builder) { AuthenticationMethod auth = getCamelContext().getTypeConverter().convertTo(AuthenticationMethod.class, proxyAuthMethod); if (auth == AuthenticationMethod.Basic || auth == AuthenticationMethod.Digest) { builder = builder.proxyAuthentication(proxyAuthUsername, proxyAuthPassword); } else { throw new IllegalArgumentException("Unknown proxyAuthMethod " + proxyAuthMethod); } return builder; }
private static void getParamsFromHeaders( Exchange exchange, Collection<String> args) { Map<String, Object> headers = exchange.getIn().getHeaders(); for (Map.Entry<String, Object> header : headers.entrySet()) { Object headerValue = header.getValue(); if (headerValue != null) { String headerStringValue = exchange.getContext().getTypeConverter() .convertTo(String.class, exchange, headerValue); args.add("--context_param " + header.getKey() + '=' + headerStringValue); } } }
private PublicKey findKeyForServerToken(InputStream knownHostsInputStream, List<String> possibleTokens) { String knowHostsLines = camelContext.getTypeConverter().convertTo(String.class, knownHostsInputStream); if (knowHostsLines == null) { log.warn("Could not read from the known_hosts file input stream"); return null; } for (String s : knowHostsLines.split("\n")) { String[] parts = s.split(" "); if (parts.length != 3) { log.warn("Found malformed entry in known_hosts file"); continue; } String entry = parts[0]; String key = parts[2]; for (String serverToken : possibleTokens) { if (entry.contains(serverToken)) { try { return loadKey(key); } catch (NoSuchAlgorithmException | InvalidKeySpecException e) { log.warn(String.format("Could not load key for server token %s", entry), e); } } } } return null; }
@Override public <T> T evaluate(Exchange exchange, Class<T> type) { Object result = ClosureSupport.call(closure, exchange); return exchange.getContext().getTypeConverter().convertTo(type, result); }
@ManagedAttribute(description = "Logging level to use when logging the progress of upload and download operations") public void setTransferLoggingLevelName(String transferLoggingLevel) { this.transferLoggingLevel = getCamelContext().getTypeConverter().convertTo(LoggingLevel.class, transferLoggingLevel); }
private static void getParamsFromHeaders( Exchange exchange, Collection<String> args) { Map<String, Object> headers = exchange.getIn().getHeaders(); for (Map.Entry<String, Object> header : headers.entrySet()) { Object headerValue = header.getValue(); if (headerValue != null) { String headerStringValue = exchange.getContext().getTypeConverter() .convertTo(String.class, exchange, headerValue); args.add("--context_param " + header.getKey() + '=' + headerStringValue); } } }
/** * Creates an HBase {@link Delete} on a specific row, using a collection of values (family/column/value pairs). */ private Delete createDeleteRow(HBaseRow hRow) throws Exception { ObjectHelper.notNull(hRow, "HBase row"); ObjectHelper.notNull(hRow.getId(), "HBase row id"); return new Delete(endpoint.getCamelContext().getTypeConverter().convertTo(byte[].class, hRow.getId())); }
/** * Renders an XDS object (either ebXML POJO or an object from the simplified model). * * @param exchange * Camel exchange. * @param body * XDS object (either ebXML POJO or an object from the simplified model). * @return * XML representation of the given XDS object. */ public static String doRender(Exchange exchange, Object body) { if (TYPES_CORRESPONDENCE.containsKey(body.getClass())) { TypeConverter converter = exchange.getContext().getTypeConverter(); body = converter.convertTo(TYPES_CORRESPONDENCE.get(body.getClass()), exchange, body); } return renderEbxml(body); }