/** * Asserts that the given expression when evaluated returns the given answer */ public static Object assertExpression(Expression expression, Exchange exchange, Object expected) { Object value; if (expected != null) { value = expression.evaluate(exchange, expected.getClass()); } else { value = expression.evaluate(exchange, Object.class); } LOG.debug("Evaluated expression: " + expression + " on exchange: " + exchange + " result: " + value); assertEquals("Expression: " + expression + " on Exchange: " + exchange, expected, value); return value; }
/** * Asserts that the given expression when evaluated returns the given answer */ public static Object assertExpression(Expression expression, Exchange exchange, Object expected) { Object value; if (expected != null) { value = expression.evaluate(exchange, expected.getClass()); } else { value = expression.evaluate(exchange, Object.class); } LOG.debug("Evaluated expression: " + expression + " on exchange: " + exchange + " result: " + value); assertEquals("Expression: " + expression + " on Exchange: " + exchange, expected, value); return value; }
/** * Asserts that the expression evaluates to one of the two given values */ protected void assertExpression(String expressionText, String expectedValue, String orThisExpectedValue) { Language language = assertResolveLanguage(getLanguageName()); Expression expression = language.createExpression(expressionText); assertNotNull("No Expression could be created for text: " + expressionText + " language: " + language, expression); Object value; if (expectedValue != null) { value = expression.evaluate(exchange, expectedValue.getClass()); } else { value = expression.evaluate(exchange, Object.class); } log.debug("Evaluated expression: {} on exchange: {} result: {}", expression, exchange, value); assertTrue("Expression: " + expression + " on Exchange: " + exchange, expectedValue.equals(value) || orThisExpectedValue.equals(value)); }
private Object getProfile(Exchange exchange) { if (profileExpression != null) { return profileExpression.evaluate(exchange, Object.class); } else { return profile; } }
/** * Applies the {@link Expression} set by {@link #params(Expression)} (or * implicitly set by {@link #staticParams(Object...)}) to obtain input * params from the <code>exchange</code>. * * @param exchange * message exchange. * @return input data or <code>null</code> if the expression evaluates to * <code>null</code> or the expression object is <code>null</code>. */ protected Object adaptParams(Exchange exchange) { if (paramsExpression == null) { return null; } return paramsExpression.evaluate(exchange, Object.class); }
/** * Applies the {@link Expression} set by {@link #input(Expression)} to * obtain input data from the <code>exchange</code>. * * @param exchange * message exchange. * @return input data or <code>null</code> if the expression evaluates to * <code>null</code> or the expression object is <code>null</code>. */ protected Object adaptInput(Exchange exchange) { if (inputExpression == null) { return null; } return inputExpression.evaluate(exchange, Object.class); }
/** * Applies the {@link Expression} set by * {@link #aggregationInput(Expression)} to obtain input data from the * <code>exchange</code>. * * @param exchange * message exchange. * @return aggregation input data or <code>null</code> if the expression * evaluates to <code>null</code> or the expression object is * <code>null</code>. */ private Object adaptAggregationInput(Exchange exchange) { if (aggregationInputExpression == null) { return null; } return aggregationInputExpression.evaluate(exchange, Object.class); }
private Iterable evaluateSplitRule(Exchange origExchange) { final Object splitResult = splitRule.evaluate(origExchange, Object.class); if (null == splitResult) { return Collections.emptySet(); } if (splitResult instanceof Iterable) { return (Iterable) splitResult; } if (splitResult instanceof Iterator) { return () -> (Iterator) splitResult; } if (splitResult.getClass().isArray()) { return Arrays.asList((Object[]) splitResult); } return Collections.singleton(splitResult); }
/** * Renders an XDS object (either ebXML POJO or an object from the simplified model) * contained in the given Camel exchange. * * @param exchange * Camel exchange containing the XDS object. * @param expression * Camel expression to extract the XDS object from the exchange. * @return * XML representation of the XDS object contained in the given Camel exchange. */ public static String render(Exchange exchange, Expression expression) { return doRender(exchange, expression.evaluate(exchange, Object.class)); }
protected Object getCorrelationKey(Exchange exchange) throws NoCorrelationKeyException { Object value; Class<?> keyType = getKeyType(); if (keyType != null) { value = correlationKeyExpression.evaluate(exchange, keyType); } else { value = correlationKeyExpression.evaluate(exchange, Object.class); } if (value == null) { throw new NoCorrelationKeyException(this, exchange); } return value; }
public void process(Exchange exchange) throws Exception { String cacheKey = key.evaluate(exchange, String.class); if (isValid(cacheManager, cacheName, cacheKey)) { Ehcache cache = cacheManager.getCache(cacheName); LOG.debug("Replacing Message Body from CacheName {} for key {}", cacheName, cacheKey); exchange.getIn().setHeader(CacheConstants.CACHE_KEY, cacheKey); exchange.getIn().setBody(cache.get(cacheKey).getObjectValue()); } }
@Override public Object getValue(String paramName) throws IllegalArgumentException { Object answer; if ("body".equals(paramName)) { answer = exchange.getIn().getBody(); } else if ((paramName.startsWith("$simple{") || paramName.startsWith("${")) && paramName.endsWith("}")) { // its a simple language expression // spring org.springframework.jdbc.core.namedparam.NamedParameterUtils.PARAMETER_SEPARATORS // uses : as parameter separator and we may use colon in simple languages as well such as bean:foo // so we have to use # instead and replace them back paramName = paramName.replace('#', ':'); answer = SimpleLanguage.expression(paramName).evaluate(exchange, Object.class); } else { answer = bodyMap.get(paramName); if (answer == null) { answer = headersMap.get(paramName); } } return answer; } }
private void parseValueExpression(Token valueSrcToken) { if (SSPTParserConstants.SIMPLE_EXP_TOKEN == valueSrcToken.kind) { final Expression exp = ExpressionBuilder.simpleExpression(valueSrcToken.toString()); this.valueExtractor = (exchange, container) -> exp.evaluate(exchange, Object.class); } else if (SSPTParserConstants.PARAMETER_POS_TOKEN == valueSrcToken.kind) { //remove leading :# final String mapKey = valueSrcToken.toString().substring(2); this.valueExtractor = (exchange, container) -> ((Map) container).get(mapKey); } }
private void parseValueExpression(Token valueSrcToken) { if (SSPTParserConstants.SIMPLE_EXP_TOKEN == valueSrcToken.kind) { final Expression exp = ExpressionBuilder.simpleExpression(valueSrcToken.toString()); this.valueExtractor = (exchange, container) -> exp.evaluate(exchange, Object.class); } else if (SSPTParserConstants.PARAMETER_POS_TOKEN == valueSrcToken.kind) { //remove leading :# final String mapKey = valueSrcToken.toString().substring(2); this.valueExtractor = (exchange, container) -> ((Map) container).get(mapKey); } }
/** * helper method to construct the hdfsPath from the CamelFileName String or Expression * @param exchange * @return */ private StringBuilder getHdfsPathUsingFileNameHeader(Exchange exchange) { StringBuilder actualPath = new StringBuilder(hdfsPath); String fileName = ""; Object value = exchange.getIn().getHeader(Exchange.FILE_NAME); if (value instanceof String) { fileName = exchange.getContext().getTypeConverter().convertTo(String.class, exchange, value); } else if (value instanceof Expression) { fileName = ((Expression) value).evaluate(exchange, String.class); } return actualPath.append(fileName); }
public <T> T evaluate(Exchange exchange, Class<T> type) { return ExpressionBuilder.constantExpression(name()).evaluate(exchange, type); }
protected static Object lookupParameter(String nextParam, Exchange exchange, Object body) { Map<?, ?> bodyMap = safeMap(exchange.getContext().getTypeConverter().tryConvertTo(Map.class, body)); Map<?, ?> headersMap = safeMap(exchange.getIn().getHeaders()); Object answer = null; if ((nextParam.startsWith("$simple{") || nextParam.startsWith("${")) && nextParam.endsWith("}")) { answer = SimpleLanguage.expression(nextParam).evaluate(exchange, Object.class); } else if (bodyMap.containsKey(nextParam)) { answer = bodyMap.get(nextParam); } else if (headersMap.containsKey(nextParam)) { answer = headersMap.get(nextParam); } return answer; }
protected String getOperationKey(Exchange exchange) { return getEndpoint().getKeyType().getExpression().evaluate(exchange, Object.class).toString(); }
protected Object createPayload(AuditEvent event) { Exchange exchange = event.getExchange(); if (exchange != null) { if (bodyExpression == null) { ExpressionDefinition expression = null; if (body != null) { expression = body.getExpression(); } if (expression != null) { bodyExpression = expression.createExpression(event.getCamelContext()); } } if (bodyExpression != null) { return bodyExpression.evaluate(exchange, Object.class); } } return event; }
protected <C> C simple(Exchange exchange, String expression, Class<C> clazz) { if (expression != null) { Expression simple = SimpleLanguage.simple(expression); if (simple != null) { return simple.evaluate(exchange, clazz); } } return getEndpoint().getCamelContext().getTypeConverter().convertTo(clazz, expression); }