{* ../../docs_src/query_params/tutorial001.py hl[9] *}

The query is the set of key-value pairs that go after the `?` in a URL, separated by `&` characters.

For example, in the URL:

```
http://127.0.0.1:8000/items/?skip=0&limit=10
```

...the query parameters are:

* `skip`: with a value of `0`
* `limit`: with a value of `10`

As they are part of the URL, they are "naturally" strings.

    public ImmutableValueGraph.Builder<N, V> putEdgeValue(N nodeU, N nodeV, V value) {
      mutableValueGraph.putEdgeValue(nodeU, nodeV, value);
      return this;
    }

    /**
     * Adds an edge connecting {@code endpoints} if one is not already present, and sets a value for
     * that edge to {@code value} (overwriting the existing value, if any).
     *

                    if (contentMap.containsKey("value")) {
                        final String[] values = DocumentUtil.getValue(contentMap, "value", String[].class);
                        if (values != null) {
                            for (final String value : values) {
                                processGroup(user, groupList, roleList, value);
                                if (!groupList.contains(value) && !roleList.contains(value)) {

		<antcall target="install.plugin">
			<param name="repo.url" value="${maven.release.repo.url}" />
			<param name="plugin.groupId" value="org/codelibs/opensearch" />
			<param name="plugin.name.prefix" value="opensearch-" />
			<param name="plugin.name" value="analysis-extension" />
			<param name="plugin.version" value="3.2.0" />
			<param name="plugin.zip.version" value="3.2.0" />
		</antcall>
		<!-- analysis-fess -->

        }
      }

      override fun toDer(
        writer: DerWriter,
        value: Long,
      ) {
        // [1950-01-01T00:00:00..2050-01-01T00:00:00Z)
        if (value in -631_152_000_000L until 2_524_608_000_000L) {
          Adapters.UTC_TIME.toDer(writer, value)
        } else {
          Adapters.GENERALIZED_TIME.toDer(writer, value)
        }
      }
    }

  /**
   * ```
   * Validity ::= SEQUENCE {

     *
     * @param boundary the alignment boundary
     * @param value the fill value for padding
     * @return the number of bytes added for alignment
     */
    public int align(final int boundary, final byte value) {
        final int n = align(boundary);
        int i = n;
        while (i > 0) {
            buf[index - i] = value;
            i--;
        }

    }

    /**
     * Subclasses should invoke this method to set the result of the computation to {@code value}.
     * This will set the state of the future to {@link OldAbstractFuture.Sync#COMPLETED} and invoke
     * the listeners if the state was successfully changed.
     *
     * @param value the value that was the result of the task.
     * @return true if the state was successfully changed.
     */

     *
     * @param array
     *            the array
     * @param value
     *            the value to search for
     * @return {@literal true} if the array contains the specified value
     */
    public static boolean contains(final long[] array, final long value) {
        return indexOf(array, value) > -1;
    }

    /**
     * Returns {@literal true} if the array contains the specified value.

        byte[] value = avSingleHost.getRaw();
        assertNotNull(value);
        assertEquals(48, value.length);

        // Verify the size field (first 4 bytes)
        assertEquals(48, (value[0] & 0xFF) | ((value[1] & 0xFF) << 8) | ((value[2] & 0xFF) << 16) | ((value[3] & 0xFF) << 24));
        // Verify the zero field (next 4 bytes)

          equal(getMap().get(entry.getKey()), entry.getValue()));
    }
  }

  private static boolean equal(@Nullable Object a, @Nullable Object b) {
    return a == b || (a != null && a.equals(b));
  }

  // This one-liner saves us from some ugly casts
  protected Entry<K, V> entry(K key, V value) {
    return mapEntry(key, value);
  }