org.antlr.v4.runtime.misc.NotNull Java Examples

/**
 * Will get the first property in a list that was provided by the user.
 * If no property was provided, the default will NOT be used.
 */
public static <T> Optional<T> getFirstProvidedValueOrEmpty(@NotNull PropertyConfiguration propertyConfiguration, @NotNull ValuedProperty<T>... properties) {
    for (ValuedProperty<T> property : properties) {
        if (propertyConfiguration.wasPropertyProvided(property)) {
            return Optional.of(propertyConfiguration.getValueOrDefault(property));
        }
    }

    return Optional.empty();
}
 

@NotNull
public <T> T getValueOrDefault(@NotNull final ValuedProperty<T> property) {
    assertPropertyNotNull(property);
    try {
        return getValue(property);
    } catch (final InvalidPropertyException e) {
        return property.getDefaultValue();
    }
}
 

public PropertyResolutionInfo(@NotNull final String source, @NotNull final String origin, @NotNull final String raw) {
    Assert.notNull(source, "Source cannot be null.");
    Assert.notNull(origin, "Origin cannot be null.");
    Assert.notNull(raw, "Raw cannot be null.");
    this.source = source;
    this.origin = origin;
    this.raw = raw;
}
 

@NotNull
private <T> PropertyValue<T> coerceValue(@NotNull final TypedProperty<T> property, @NotNull final PropertyResolutionInfo propertyResolutionInfo) {
    Assert.notNull(property, "Cannot resolve a null property.");
    Assert.notNull(propertyResolutionInfo, "Cannot coerce a null property resolution.");
    try {
        final T value = property.getValueParser().parse(propertyResolutionInfo.getRaw());
        return new ValuedPropertyValue<>(value, propertyResolutionInfo);
    } catch (final ValueParseException e) {
        return new ExceptionPropertyValue<>(e, propertyResolutionInfo);
    }
}
 

@NotNull
private <T> PropertyValue<T> valueFromCache(@NotNull final TypedProperty<T> property) {
    if (!valueCache.containsKey(property.getKey())) {
        valueCache.put(property.getKey(), valueFromResolution(property));
    }

    @SuppressWarnings("unchecked") final PropertyValue<T> value = (PropertyValue<T>) valueCache.get(property.getKey());
    Assert.notNull(value, "Could not source a value, something has gone wrong with properties!");
    return value;
}
 

@NotNull
public <T> Optional<T> getValueOrEmpty(@NotNull final NullableProperty<T> property) {
    assertPropertyNotNull(property);
    try {
        return getValue(property);
    } catch (final InvalidPropertyException e) {
        return Optional.empty();
    }
}
 

private PropertyResolution resolveFromPropertySources(@NotNull final String key) {
    Assert.notNull(key, "Cannot resolve a null key.");
    for (final PropertySource propertySource : orderedPropertySources) {
        if (propertySource.hasKey(key)) {
            final String rawValue = propertySource.getValue(key);
            if (rawValue != null) {
                final String name = propertySource.getName();
                final String origin = propertySource.getOrigin(key);
                final PropertyResolutionInfo propertyResolutionInfo = new PropertyResolutionInfo(name, origin, rawValue);
                return new SourcePropertyResolution(propertyResolutionInfo);
            }
        }
    }
    return new NoPropertyResolution();
}
 

@NotNull
public Set<String> getKeys() {
    return orderedPropertySources.stream()
               .map(PropertySource::getKeys)
               .flatMap(Set::stream)
               .collect(Collectors.toSet());
}
 

@NotNull
public List<Pattern> getIgnoredProxyHostPatterns() {
    return ignoredProxyHostPatterns;
}
 

@NotNull
public Long getTimeout() {
    return timeout;
}
 

public <T> Optional<ValueParseException> getPropertyException(@NotNull final TypedProperty<T> property) {
    assertPropertyNotNull(property);
    return valueFromCache(property).getException();
}
 

@NotNull
public String getName() {
    return name;
}
 

@NotNull
public static <E extends Enum<E>> SoftEnumValue<E> ofEnumValue(@NotNull final E enumValue) {
    return new SoftEnumValue<>(null, enumValue);
}
 

@NotNull
ExecutableOutput execute(final File workingDirectory, final File exeFile, final String... args) throws ExecutableRunnerException;
 

@NotNull
Boolean hasKey(String key);
 

public <T> boolean wasPropertyProvided(@NotNull final TypedProperty<T> property) {
    assertPropertyNotNull(property);
    return wasKeyProvided(property.getKey());
}
 

@NotNull
public ProxyInfo getProxyInformation() {
    return proxyInformation;
}
 

@NotNull
String getName();
 

@NotNull
public String getRaw() {
    return raw;
}
 

@NotNull
public Map<String, String> getBlackduckProperties() {
    return blackduckProperties;
}
 

@NotNull
public String getDisplayValue() {
    return String.format("%s.0.0", getIntValue());
}
 

protected Category(@NotNull final String name) {
    this.name = name;
}
 

/**
 * Exit a parse tree produced by the {@code StartsWithRelationalExpression}
 * labeled alternative in {@link EqlGrammarParser#relational_expression}.
 * @param ctx the parse tree
 */
void exitStartsWithRelationalExpression(@NotNull EqlGrammarParser.StartsWithRelationalExpressionContext ctx);
 

/**
 * {@inheritDoc}
 *
 * <p>The default implementation does nothing.</p>
 */
@Override public void enterSubExpression(@NotNull EqlGrammarParser.SubExpressionContext ctx) { }
 

/**
 * {@inheritDoc}
 *
 * <p>The default implementation does nothing.</p>
 */
@Override public void exitAtomFactor(@NotNull EqlGrammarParser.AtomFactorContext ctx) { }
 

/**
 * Enter a parse tree produced by the {@code ParenthesisBooleanNotExpression}
 * labeled alternative in {@link EqlGrammarParser#boolean_not_expression}.
 * @param ctx the parse tree
 */
void enterParenthesisBooleanNotExpression(@NotNull EqlGrammarParser.ParenthesisBooleanNotExpressionContext ctx);
 

/**
 * {@inheritDoc}
 *
 * <p>The default implementation does nothing.</p>
 */
@Override public void exitSubExpression(@NotNull EqlGrammarParser.SubExpressionContext ctx) { }
 

/**
 * {@inheritDoc}
 *
 * <p>The default implementation does nothing.</p>
 */
@Override public void enterStringDoubleQuote(@NotNull EqlGrammarParser.StringDoubleQuoteContext ctx) { }
 

/**
 * {@inheritDoc}
 *
 * <p>The default implementation does nothing.</p>
 */
@Override public void exitNumeric_constant(@NotNull EqlGrammarParser.Numeric_constantContext ctx) { }
 

/**
 * {@inheritDoc}
 *
 * <p>The default implementation does nothing.</p>
 */
@Override public void exitEqRelationalRelationalExpression(@NotNull EqlGrammarParser.EqRelationalRelationalExpressionContext ctx) { }