}

        }
    }

    /**
     * Use a exclusive connection for this tree
     *
     * If an exclusive connection is used the caller must make sure that the tree handle is kept alive,
     * otherwise the connection will be disconnected once the usage drops to zero.
     *
     * @param np
     *            whether to use an exclusive connection

   *
   * <p>The returned array will be "safe" in that no references to it are maintained by this queue.
   * (In other words, this method must allocate a new array). The caller is thus free to modify the
   * returned array.
   *
   * <p>This method acts as bridge between array-based and collection-based APIs.
   *
   * @return an array containing all of the elements in this queue
   */

     * newFuture is a future that completes after this and all prior tasks are done.
     * oldFuture is the previous task's newFuture.
     * outputFuture is the future we return to the caller, a nonCancellationPropagating taskFuture.
     *
     * newFuture is guaranteed to only complete once all tasks previously submitted to this instance

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<AccessTokenCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<AccessTokenCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

        if (states != null) {
            final long now = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();
            states.entrySet()
                    .stream()
                    .filter(e -> (now - e.getValue().getExpiration()) / 1000L > getStateTtl())
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList())
                    .forEach(s -> {

behavior of some watch calls to the server when filtering on fields was incorrect. If watching objects with a filter, when an update was made that no longer matched the filter a DELETE event was correctly sent. However, the object that was returned by that delete was not the (correct) version before the update, but instead, the newer version. That meant the new object was not matched by the filter. This was a regression from behavior between cached watches on the server side and uncached watches, and...

     *
     * @return The created OpenSearch client.
     */
    protected Client createClient() {
        final String[] hosts =
                split(address, ",").get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        final Settings settings = Settings.builder().putList("http.hosts", hosts).build();
        return new HttpClient(settings, null);
    }

    /**

     * @param message event message
     * @param context additional context
     */
    public void logEvent(EventType type, Severity severity, String message, Map<String, Object> context) {
        // Check minimum log level filter
        if (severity.getLevel() < minLogLevel.getLevel()) {
            return;
        }

        // Rate limiting check
        if (!checkRateLimit(type)) {
            return;
        }

  }

  private static Type[] toArray(Collection<Type> types) {
    return types.toArray(new Type[0]);
  }

  private static Iterable<Type> filterUpperBounds(Iterable<Type> bounds) {
    return Iterables.filter(bounds, Predicates.not(Predicates.<Type>equalTo(Object.class)));
  }

  private static void disallowPrimitiveType(Type[] types, String usedAs) {
    for (Type type : types) {
      if (type instanceof Class) {

     *
     * In theory, we can quickly determine the size of any Collection. However, thanks to
     * regrettable implementations like our own Sets.filter, Collection.size() is sometimes a
     * linear-time operation, and it can even have side effects. Thus, we limit the special case to
     * List, which is _even more likely_ to have size() implemented to be fast and side-effect-free.