// 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.

 *
 * @see FileTree#visit(groovy.lang.Closure)
 */
public interface FileVisitDetails extends FileTreeElement {

    /**
     * Requests that file visiting terminate after the current file.
     */
    void stopVisiting();

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

	return r.targetsSingleItems
}

// IgnoreErrors will filter errors that occur when by visiting the result
// (but not errors that occur by creating the result in the first place),
// eliminating any that match fns. This is best used in combination with
// Builder.ContinueOnError(), where the visitors accumulate errors and return
// them after visiting as a slice of errors. If no errors remain after

You must grant your default compute service account the correct permissions before creating the deployment.
Otherwise, the installation will fail.

> Note the **Project Number** for your project by visiting the [Dashboard Page](https://console.cloud.google.com/homehttps://console.cloud.google.com/home) of Google Cloud Console.

Navigate to the [IAM section](https://console.cloud.google.com/permissions/projectpermissions)

    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