TypeVisitResult visitType(Class<? super T> type);
    }

    public static enum TypeVisitResult {
        /**
         * Continue visiting.
         */
        CONTINUE,

        /**
         * Terminate visiting immediately.
         */
        TERMINATE
    }

// if visiting should continue.
type ContainerVisitor func(container *api.Container, containerType ContainerType) (shouldContinue bool)

// VisitContainers invokes the visitor function with a pointer to every container
// spec in the given pod spec with type set in mask. If visitor returns false,
// visiting is short-circuited. VisitContainers returns true if visiting completes,
// false if visiting was short-circuited.

else
   tfrun bazel test $TFCI_BAZEL_COMMON_ARGS --profile "$TFCI_OUTPUT_DIR/profile.json.gz" --config="${TFCI_BAZEL_TARGET_SELECTING_CONFIG_PREFIX}_pycpp_test"
fi

# Note: the profile can be viewed by visiting chrome://tracing in a Chrome browser.
# See https://docs.bazel.build/versions/main/skylark/performance.html#performance-profiling

    protected abstract void visitCause(Throwable cause);

    protected abstract void visitLocation(String location);

    /**
     * Should be called after each time this visitor has finished visiting.
     *
     * This method can be used to perform any cleanup or final processing related
     * to the visitor's purpose.
     */
    protected void endVisiting() {
        // default is no-op
    }

import org.gradle.internal.RelativePathSupplier;

import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;

/**
 * Tracks the relative path. Useful when visiting {@link FileSystemLocationSnapshot}s.
 */
public class RelativePathTracker implements RelativePathSupplier {
    private final Deque<String> segments = new ArrayDeque<>();
    private String rootName;

 */

package org.gradle.internal.execution.history.changes;

import java.util.ArrayList;
import java.util.List;

/**
 * An implementation that will cache a number of results of visiting, and make them available for subsequent visits.
 * When the cache is overrun, then the delegate will be visited directly in further requests.
 * If a visitor does not consume all the changes, then nothing is cached.
 */

                    if (connectedNodeDetails == null) {
                        // Have not visited the successor node, so add to the queue for visiting
                        queue.addFirst(connectedNode);
                    } else if (!connectedNodeDetails.finished) {
                        // Currently visiting the successor node - we're in a cycle
                        details.stronglyConnected = true;
                    }

            if (resolveState.peek() != null) {
                final NodeState node = resolveState.pop();
                LOGGER.debug("Visiting configuration {}.", node);

                // Register capabilities for this node
                registerCapabilities(resolveState, node);

                // Initialize and collect any new outgoing edges of this node

            receivesChanges(change3, change2, change1)
        }
        0 * _

        and:
        reported == [change3, change2, change1]
    }

    def "does not cache if visitor aborts visiting"() {
        when:
        cachingChanges.accept(new LimitingChangeVisitor(2, new CollectingChangeVisitor()))

        then:
        interaction {
            receivesChanges(change1, change2)
        }

     * <p>
     * The collection is live, so that the contents are queried as required on query of the collection.
     *
     * @param contents The file set contents for the constructed file collection