* @param soff the offset in the source array
     * @param slen the length of data to process
     * @param dst the destination array for the result
     * @param doff the offset in the destination array
     */
    public void update(final byte[] src, int soff, final int slen, final byte[] dst, int doff) {
        int slim = soff + slen;
        while (soff < slim) {
            i = i + 1 & 0xff;

       */
      seenExceptionsLocal = requireNonNull(seenExceptionsField);
    }
    return seenExceptionsLocal;
  }

  /** Populates {@code seen} with the exception that was passed to {@code setException}. */
  abstract void addInitialException(Set<Throwable> seen);

  final int decrementRemainingAndGet() {
    return ATOMIC_HELPER.decrementAndGetRemainingCount(this);
  }

  final void clearSeenExceptions() {

        new LineProcessor<Integer>() {
          int seen;

          @Override
          public boolean processLine(String line) {
            seen++;
            sb.append(line);
            return seen < 2;
          }

          @Override
          public Integer getResult() {
            return seen;
          }
        };

        new LineProcessor<Integer>() {
          int seen;

          @Override
          public boolean processLine(String line) {
            seen++;
            sb.append(line);
            return seen < 2;
          }

          @Override
          public Integer getResult() {
            return seen;
          }
        };

| `minio_node_replication_max_queued_count`               | Maximum number of objects queued for replication seen since server start                                 |
| `minio_node_replication_recent_backlog_count`           | Total number of objects seen in replication backlog in the last 5 minutes                                |

     */
    private int countUniqueBytes(byte[] data) {
        boolean[] seen = new boolean[256];
        int count = 0;

        for (byte b : data) {
            int index = b & 0xFF;
            if (!seen[index]) {
                seen[index] = true;
                count++;
            }
        }

        return count;
    }

    void codes_are_non_negative_and_unique() {
        // Edge checks: ensure there are no negative or duplicate codes
        Set<Integer> seen = new HashSet<>();
        for (int c : WinError.WINERR_CODES) {
            assertTrue(c >= 0, "Code should be non-negative: " + c);
            assertTrue(seen.add(c), "Duplicate code detected: " + c);
        }
    }

    // Simple collaborator to demonstrate interaction verification with Mockito

And the same for <abbr title="less than"><code>lt</code></abbr>.

{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *}

## Recap { #recap }

With `Query`, `Path` (and others you haven't seen yet) you can declare metadata and string validations in the same ways as with [Query Parameters and String Validations](query-params-str-validations.md){.internal-link target=_blank}.

And you can also declare numeric validations:

      for (Entry<E> entry : insertionOrder) {
        map.put(entry.getElement(), entry);
      }

      Set<E> seen = new HashSet<>();
      List<Entry<E>> order = new ArrayList<>();
      for (E e : gen.order(new ArrayList<E>(map.keySet()))) {
        if (seen.add(e)) {
          order.add(map.get(e));
        }
      }
      return order;
    }
  }

# Advanced Dependencies { #advanced-dependencies }

## Parameterized dependencies { #parameterized-dependencies }

All the dependencies we have seen are a fixed function or class.

But there could be cases where you want to be able to set parameters on the dependency, without having to declare many different functions or classes.

Let's imagine that we want to have a dependency that checks if the query parameter `q` contains some fixed content.