Vous verrez quelque chose comme :

```JSON
{"item_id": 5, "q": "somequery"}
```

## Documentation interactive de l'API

 *   }
 * }.visit(type);
 * }
 *
 * <p>One {@code Type} is visited at most once. The second time the same type is visited, it's
 * ignored by {@link #visit}. This avoids infinite recursion caused by recursive type bounds.
 *
 * <p>This class is not thread safe.
 *
 * @author Ben Yu
 */
abstract class TypeVisitor {

  private final Set<Type> visited = new HashSet<>();

  /**

 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook;

public interface JavadocLexer {
    /**
     * Visits the tokens in the input stream for this lexer. Reads to the end of the input.
     */
    void visit(TokenVisitor visitor);

    class TokenVisitor {
        void onStartHtmlElement(String name) {
        }

        void onHtmlElementAttribute(String name, String value) {

        lexer.visit(visitor)

        then:
        1 * visitor.onStartJavadocTag('tag')
        1 * visitor.onText('some value')
        1 * visitor.onEndJavadocTag('tag')
        1 * visitor.onEnd()
        0 * visitor._
    }

    def javadocTagCanBeEmpty() {
        when:
        lexer.pushText("{@empty}")
        lexer.visit(visitor)

        then:
        1 * visitor.onStartJavadocTag('empty')

        return sortedNodes;
    }

    // Helper method to visit a node
    private static void visitNode(BuildStep node, Set<BuildStep> visited, List<BuildStep> sortedNodes) {
        if (visited.add(node)) {
            // For each successor of the current node, visit unvisited successors
            node.successors.forEach(successor -> visitNode(successor, visited, sortedNodes));
            sortedNodes.add(node);
        }
    }

            return g;
        }

        List<MetadataGraphVertex> visited = new ArrayList<>(g.getVertices().size());
        visit(g.getEntry(), visited, g);

        List<MetadataGraphVertex> dropList = new ArrayList<>(g.getVertices().size());

        // collect drop list
        for (MetadataGraphVertex v : g.getVertices()) {
            if (!visited.contains(v)) {
                dropList.add(v);
            }
        }

        public VisitorImpl(TokenVisitor visitor) {
            this.visitor = visitor;
        }

        private void unwindTo(String element, TokenVisitor visitor) {
            if (elementStack.contains(element)) {
                while (!elementStack.getFirst().equals(element)) {
                    visitor.onEndHtmlElement(elementStack.removeFirst());
                }
                elementStack.removeFirst();

        ClasspathContainer cpc;

        List<MetadataGraphVertex> visited;

        // -----------------------------------------------------------------------
        protected ClasspathGraphVisitor(MetadataGraph cleanGraph, ClasspathContainer cpc) {
            this.cpc = cpc;
            this.graph = cleanGraph;

            visited = new ArrayList<>(cleanGraph.getVertices().size());
        }

     */
    protected void extractFrontMatterMetadata(final Node document, final ExtractData extractData) {
        final YamlFrontMatterVisitor visitor = new YamlFrontMatterVisitor();
        document.accept(visitor);

        final Map<String, List<String>> frontMatter = visitor.getData();
        for (final Map.Entry<String, List<String>> entry : frontMatter.entrySet()) {
            final String key = "frontmatter." + entry.getKey();

            scanner.find('}');
            String value = scanner.region();
            visitor.onText(value);
        }

        // end of tag marker
        if (scanner.lookingAt('}')) {
            visitor.onEndJavadocTag(tagName);
            scanner.next();
        }
    }

    private void parseStartElement(TokenVisitor visitor) {
        // start element marker
        scanner.next();