org.apache.camel.model.language.ExpressionDefinition Java Examples

@Override
public ExpressionDefinition getExpression() {
    final ExpressionSubElementDefinition expression = super.getCorrelationExpression();

    return expression != null
        ? super.getCorrelationExpression().getExpressionType()
        : null;
}
 

@Override
public ExpressionDefinition getExpression() {
    return super.getExpressionType();
}
 

public static String getExpressionOrElse(ExpressionDefinition exp, String defaultValue) {
    if (exp != null) {
        return Strings2.getOrElse(exp.getExpression(), defaultValue).trim();
    }
    return defaultValue;
}
 

public static String getExpressionOrElse(ExpressionDefinition exp) {
    return getExpressionOrElse(exp, "");
}
 

private void expressionOptions(String k, ExpressionDefinition exp, Map<String, String> options) {
    // special for aggregate as it has naming clash
    if ("completionSizeExpression".equals(k)) {
        k = "completionSize";
    } else if ("completionTimeoutExpression".equals(k)) {
        k = "completionTimeout";
    }

    String text = exp.getExpression();
    String lan = exp.getLanguage();
    options.put(k, lan);
    if (text != null) {
        options.put(k + "_value", text);
    }

    // when using a language as an expression it can contain additional options which we
    // cannot build a nice UI in forge as forge is not that dynamic. So instead we have an extra
    // input field where we allow users to edit the values using a Camel multivalue uri style with
    // key=value&key2=value2 ...
    CollectionStringBuffer csb = new CollectionStringBuffer("&");
    String json = getCamelCatalog().languageJSonSchema(lan);
    if (json != null) {
        List<Map<String, String>> data = JSonSchemaHelper.parseJsonSchema("properties", json, true);
        if (data != null) {
            for (Map<String, String> map : data) {
                String name = map.get("name");
                // skip expression/id as we are not interested in those
                if (name != null && !"id".equals(name) && !"expression".equals(name)) {
                    try {
                        Object value = IntrospectionSupport.getProperty(exp, name);
                        if (value != null) {
                            text = value.toString();
                            csb.append(name + "=" + text);
                        }
                    } catch (Exception e) {
                        // ignore
                    }
                }
            }
        }
        if (!csb.isEmpty()) {
            String extra = csb.toString();
            options.put(k + "_extra", extra);
        }
    }
}
 

public final TypeSpec generateHasExpression() {
    TypeSpec.Builder type = TypeSpec.interfaceBuilder("HasExpression");
    type.addModifiers(Modifier.PUBLIC);
    type.addMethod(
        MethodSpec.methodBuilder("setExpression")
            .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
            .addParameter(ExpressionDefinition.class, "expressionDefinition")
            .addAnnotation(
                AnnotationSpec.builder(JsonTypeInfo.class)
                    .addMember("use", "$L", "JsonTypeInfo.Id.NAME")
                    .addMember("include", "$L", "JsonTypeInfo.As.WRAPPER_OBJECT")
                    .build())
            .build()
    );

    type.addMethod(
        MethodSpec.methodBuilder("getExpression")
            .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
            .returns(ExpressionDefinition.class)
            .build()
    );

    definitions(EXPRESSION_DEFINITION_CLASS).forEach(
        (k, v) -> {
            String name = k;
            name = WordUtils.capitalize(name, '_', '-');
            name = StringUtils.remove(name, "_");
            name = StringUtils.remove(name, "-");

            type.addMethod(MethodSpec.methodBuilder("set" + name)
                .addAnnotation(
                    AnnotationSpec.builder(JsonAlias.class).addMember("value", "$S", k).build())
                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
                .addParameter(v, "definition")
                .addCode(
                    CodeBlock.builder()
                        .beginControlFlow("if (getExpression() != null)")
                        .addStatement("throw new IllegalArgumentException(\"And expression has already been set\")")
                        .endControlFlow()
                        .addStatement("setExpression(definition);").build())
                .build()
            );
        }
    );

    return type.build();
}
 

@Override
public ExpressionDefinition getExpression() {
    return super.getExpressionType();
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    super.setExpressionType(expressionDefinition);
}
 

@JsonIgnore
@Override
public void setExpressionType(ExpressionDefinition expressionType) {
    super.setExpressionType(expressionType);
}
 

@JsonIgnore
@Override
public ExpressionDefinition getExpressionType() {
    return super.getExpressionType();
}
 

@Override
public ExpressionDefinition getExpression() {
    return delegate.getExpression() != null
        ? new ExpressionDefinition(delegate.getExpression())
        : null;
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    delegate.setExpression(expressionDefinition);
}
 

@Override
public Expression createExpression(ExpressionDefinition definition) {
    return ExpressionReifier.reifier(this, definition).createExpression();
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    super.setExpressionType(expressionDefinition);
}
 

@Override
public ExpressionDefinition getExpression() {
    return super.getExpressionType();
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    super.setExpressionType(expressionDefinition);
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    super.setCorrelationExpression(expressionDefinition);
}
 

@Override
public ExpressionDefinition getExpression() {
    return super.getExpressionType();
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    super.setExpressionType(expressionDefinition);
}
 

@Override
public ExpressionDefinition getExpression() {
    return super.getExpressionType();
}
 

@Override
public void setExpression(ExpressionDefinition expressionDefinition) {
    super.setExpressionType(expressionDefinition);
}
 

@Override
public Predicate createPredicate(ExpressionDefinition definition) {
    return ExpressionReifier.reifier(this, definition).createPredicate();
}