Java ParameterDescriptor类代码示例

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Inject
public SelectJsonPath(ObjectMapper objectMapper) {
    configuration = Configuration.builder()
            .options(Option.SUPPRESS_EXCEPTIONS)
            .jsonProvider(new JacksonJsonNodeJsonProvider(objectMapper))
            .build();

    jsonParam = ParameterDescriptor.type("json", JsonNode.class).description("A parsed JSON tree").build();
    // sigh generics and type erasure
    //noinspection unchecked
    pathsParam = ParameterDescriptor.type("paths",
                                          (Class<Map<String, String>>) new TypeLiteral<Map<String, String>>() {}.getRawType(),
                                          (Class<Map<String, JsonPath>>) new TypeLiteral<Map<String, JsonPath>>() {}.getRawType())
            .transform(inputMap -> inputMap
                    .entrySet().stream()
                    .collect(toMap(Map.Entry::getKey, e -> JsonPath.compile(e.getValue()))))
            .description("A map of names to a JsonPath expression, see http://jsonpath.com")
            .build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Override
public void exitFunctionCall(RuleLangParser.FunctionCallContext ctx) {
    final FunctionExpression expr = (FunctionExpression) parseContext.expressions().get(ctx);
    final FunctionDescriptor<?> descriptor = expr.getFunction().descriptor();
    final FunctionArgs args = expr.getArgs();
    for (ParameterDescriptor p : descriptor.params()) {
        final Expression argExpr = args.expression(p.name());
        if (argExpr != null && !p.type().isAssignableFrom(argExpr.getType())) {
            parseContext.addError(new IncompatibleArgumentType(ctx, expr, p, argExpr));
        }
    }
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
public IncompatibleArgumentType(RuleLangParser.FunctionCallContext ctx,
                                FunctionExpression functionExpression,
                                ParameterDescriptor p,
                                Expression argExpr) {
    super("incompatible_argument_type", ctx);
    this.functionExpression = functionExpression;
    this.p = p;
    this.argExpr = argExpr;
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
public MissingRequiredParam(RuleLangParser.FunctionCallContext ctx,
                            Function<?> function,
                            ParameterDescriptor param) {
    super("missing_required_param", ctx);
    this.function = function;
    this.param = param;
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@JsonProperty("reason")
@Override
public String toString() {
    final Predicate<ParameterDescriptor> optional = ParameterDescriptor::optional;
    return "Expected " + function.descriptor().params().stream().filter(optional.negate()).count() +
            " arguments but found " + argCount +
            " in call to function " + function.descriptor().name()
            + positionString();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@JsonProperty("reason")
@Override
public String toString() {
    int paramPosition = 1;
    for (ParameterDescriptor descriptor : function.descriptor().params()) {
        if (descriptor.name().equals(failure.getArgumentName())) {
            break;
        }
        paramPosition++;
    }

    return "Unable to pre-compute value for " + ordinal(paramPosition) + " argument " + failure.getArgumentName() + " in call to function " + function.descriptor().name() + ": " + failure.getCause().getMessage();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
public CidrMatch() {
    // a little ugly because newCIDR throws a checked exception :(
    cidrParam = ParameterDescriptor.string("cidr", CIDR.class).transform(cidrString -> {
        try {
            return CIDR.newCIDR(cidrString);
        } catch (UnknownHostException e) {
            throw new IllegalArgumentException(e);
        }
    }).description("The CIDR subnet mask").build();
    ipParam = ParameterDescriptor.type(IP, IpAddress.class).description("The parsed IP address to match against the CIDR mask").build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Override
protected ImmutableList<ParameterDescriptor> params() {
    return ImmutableList.of(
            valueParam,
            defaultParam
    );
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Override
protected ImmutableList<ParameterDescriptor> params() {
    return ImmutableList.of(
            valueParam,
            patternParam,
            localeParam
    );
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
protected TimezoneAwareFunction() {
    timeZoneParam = ParameterDescriptor
            .string(TIMEZONE, DateTimeZone.class)
            .transform(id -> DateTimeZone.forID(UPPER_ZONE_MAP.getOrDefault(id.toUpperCase(Locale.ENGLISH), "UTC")))
            .optional()
            .description("The timezone to apply to the date, defaults to UTC")
            .build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Override
public FunctionDescriptor<DateTime> descriptor() {
    return FunctionDescriptor.<DateTime>builder()
            .name(getName())
            .returnType(DateTime.class)
            .params(ImmutableList.<ParameterDescriptor>builder()
                            .addAll(params())
                            .add(timeZoneParam)
                            .build())
            .description(description())
            .build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
public FormatDate() {
    value = ParameterDescriptor.type("value", DateTime.class).description("The date to format").build();
    format = ParameterDescriptor.string("format", DateTimeFormatter.class)
            .transform(DateTimeFormat::forPattern)
            .description("The format string to use, see http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html")
            .build();
    timeZoneParam = ParameterDescriptor.string("timezone", DateTimeZone.class)
            .transform(DateTimeZone::forID)
            .optional()
            .description("The timezone to apply to the date, defaults to UTC")
            .build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Inject
public GrokMatch(GrokPatternRegistry grokPatternRegistry) {
    this.grokPatternRegistry = grokPatternRegistry;

    valueParam = ParameterDescriptor.string("value").description("The string to apply the Grok pattern against").build();
    patternParam = ParameterDescriptor.string("pattern").description("The Grok pattern").build();
    namedOnly = ParameterDescriptor.bool("only_named_captures").optional().description("Whether to only use explicitly named groups in the patterns").build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
public StringUtilsFunction() {
    valueParam = ParameterDescriptor.string(VALUE).description("The input string").build();
    localeParam = ParameterDescriptor.string(LOCALE, Locale.class)
            .optional()
            .transform(Locale::forLanguageTag)
            .description("The locale to use, defaults to English")
            .build();
}
 

import org.graylog.plugins.pipelineprocessor.ast.functions.ParameterDescriptor; //导入依赖的package包/类
@Override
public FunctionDescriptor<String> descriptor() {
    ImmutableList.Builder<ParameterDescriptor> params = ImmutableList.builder();
    params.add(valueParam);
    if (isLocaleAware()) {
        params.add(localeParam);
    }
    return FunctionDescriptor.<String>builder()
            .name(getName())
            .returnType(String.class)
            .params(params.build())
            .description(description())
            .build();
}