javax.annotation.CheckReturnValue Java Examples

/**
 * Prepares for a check that the subject is deadline within the given tolerance of an
 * expected value that will be provided in the next call in the fluent chain.
 */
@CheckReturnValue
public TolerantDeadlineComparison isWithin(final long delta, final TimeUnit timeUnit) {
  return new TolerantDeadlineComparison() {
    @Override
    public void of(Deadline expected) {
      Deadline actual = actual();
      checkNotNull(actual, "actual value cannot be null. expected=%s", expected);

      // This is probably overkill, but easier than thinking about overflow.
      BigInteger actualTimeRemaining = BigInteger.valueOf(actual.timeRemaining(NANOSECONDS));
      BigInteger expectedTimeRemaining = BigInteger.valueOf(expected.timeRemaining(NANOSECONDS));
      BigInteger deltaNanos = BigInteger.valueOf(timeUnit.toNanos(delta));
      if (actualTimeRemaining.subtract(expectedTimeRemaining).abs().compareTo(deltaNanos) > 0) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "%s and <%s> should have been within <%sns> of each other",
                    actualAsString(), expected, deltaNanos)));
      }
    }
  };
}
 

/** Returns {@code false} when client is misbehaving and should be disconnected. */
@CheckReturnValue
public boolean pingAcceptable() {
  long now = ticker.nanoTime();
  boolean valid;
  if (!hasOutstandingCalls && !permitWithoutCalls) {
    valid = compareNanos(lastValidPingTime + IMPLICIT_PERMIT_TIME_NANOS, now) <= 0;
  } else {
    valid = compareNanos(lastValidPingTime + minTimeNanos, now) <= 0;
  }
  if (!valid) {
    pingStrikes++;
    return !(pingStrikes > MAX_PING_STRIKES);
  } else {
    lastValidPingTime = now;
    return true;
  }
}
 

@Override
@CheckReturnValue
protected NettyServer buildTransportServer(
    List<ServerStreamTracer.Factory> streamTracerFactories) {
  ProtocolNegotiator negotiator = protocolNegotiator;
  if (negotiator == null) {
    negotiator = sslContext != null ? ProtocolNegotiators.serverTls(sslContext) :
            ProtocolNegotiators.serverPlaintext();
  }

  return new NettyServer(
      address, channelType, channelOptions, bossEventLoopGroup, workerEventLoopGroup,
      negotiator, streamTracerFactories, transportTracerFactory,
      maxConcurrentCallsPerConnection, flowControlWindow,
      maxMessageSize, maxHeaderListSize, keepAliveTimeInNanos, keepAliveTimeoutInNanos,
      maxConnectionIdleInNanos,
      maxConnectionAgeInNanos, maxConnectionAgeGraceInNanos,
      permitKeepAliveWithoutCalls, permitKeepAliveTimeInNanos, channelz);
}
 

@CheckReturnValue
public Graql.Token.Compute.Algorithm using() {
    if (algorithm == null) {
        return Graql.Token.Compute.Algorithm.DEGREE;
    } else {
        return algorithm;
    }
}
 

@CheckReturnValue
@SuppressWarnings("unchecked")
default T where(U arg, U... args) {
    ArrayList<U> argList = new ArrayList<>(args.length + 1);
    argList.add(arg);
    argList.addAll(Arrays.asList(args));

    return where(argList);
}
 

/**
 * @param patterns a collection of patterns to match
 * @return a pattern that will match when any contained pattern matches
 */
@CheckReturnValue
public static Pattern or(Collection<? extends Pattern> patterns) {
    // Simplify representation when there is only one alternative
    if (patterns.size() == 1) {
        return patterns.iterator().next();
    }

    return or(new LinkedHashSet<>(patterns));
}
 

@CheckReturnValue
default T of(String type, String... types) {
    ArrayList<String> typeList = new ArrayList<>(types.length + 1);
    typeList.add(type);
    typeList.addAll(Arrays.asList(types));

    return of(typeList);
}
 

@Nullable
@CheckReturnValue
public MatchClause match() {
    return match;
}
 

@CheckReturnValue
public static StatementAttribute eq(double value) {
    return hiddenVar().eq(value);
}
 

@CheckReturnValue
T in(Collection<String> types);
 

@CheckReturnValue
public static StatementAttribute neq(boolean value) {
    return hiddenVar().neq(value);
}
 

/**
 * @param statements a collection of statements that indicate properties to delete
 * @return a delete query that will delete the given variables for each result of this match clause
 */
@CheckReturnValue
public final GraqlDelete delete(Collection<? extends Statement> statements) {
    return new GraqlDelete(this, new ArrayList<>(statements));
}
 

@CheckReturnValue
public MatchClause match() {
    return match;
}
 

@CheckReturnValue
default StatementAttribute neq(boolean value) {
    return neq(Comparison.Boolean::new, value);
}
 

@CheckReturnValue
public Set<Graql.Token.Compute.Param> getParameters() {
    return argumentsOrdered.keySet();
}
 

@CheckReturnValue
default StatementAttribute gt(LocalDateTime value) {
    return gt(Comparison.DateTime::new, value);
}
 

@CheckReturnValue
public static StatementAttribute contains(Statement variable) {
    return hiddenVar().contains(variable);
}
 

@CheckReturnValue
public boolean includesAttributes() {
    return includeAttributes;
}
 

@CheckReturnValue
public static StatementAttribute eq(String value) {
    return hiddenVar().eq(value);
}
 

@CheckReturnValue
default StatementAttribute lte(String value) {
    return lte(Comparison.String::new, value);
}
 

@CheckReturnValue
public static StatementAttribute lte(String value) {
    return hiddenVar().lte(value);
}
 

/**
 * Construct a get query with all all variables mentioned in the query
 */
@CheckReturnValue
public GraqlGet.Unfiltered get() {
    return new GraqlGet.Unfiltered(this);
}
 

@CheckReturnValue
public final Set<Variable> getSelectedNames() {
    return pattern.variables();
}
 

/**
 * @param type a resource type that this type variable can be related to
 * @return this
 */
@CheckReturnValue
default StatementType has(String type) {
    return has(Graql.type(type));
}
 

@CheckReturnValue
public static StatementAttribute lte(LocalDateTime value) {
    return hiddenVar().lte(value);
}
 

@CheckReturnValue
public static StatementAttribute eq(boolean value) {
    return hiddenVar().eq(value);
}
 

@CheckReturnValue
Disjunction<Conjunction<Pattern>> getNegationDNF();
 

@CheckReturnValue
T to(String toID);
 

/**
 * @return a new statement with an anonymous Variable
 */
@CheckReturnValue
public static Statement var() {
    return var(new Variable());
}
 

/**
 * @return the patterns within this conjunction
 */
@CheckReturnValue
public Set<T> getPatterns() {
    return patterns;
}