}

    @Override
    public void visit(Visitor visitor) {
        visitor.visitArtifacts(this);
    }

    @Override
    public void startFinalization(BuildOperationQueue<RunnableBuildOperation> actions, boolean requireFiles) {
    }

    @Override
    public void visit(ArtifactVisitor visitor) {
        for (final ResolvedArtifact artifact : artifacts) {

        }

        override fun visit(visitor: ResolvedArtifactSet.Visitor) {
            visitor.visitArtifacts(this)
        }

        override fun startFinalization(actions: BuildOperationQueue<RunnableBuildOperation>, requireFiles: Boolean) {
        }

        override fun visit(visitor: ArtifactVisitor) {
            val displayName = Describables.of(ownerId)

    public void describe(DiagnosticsVisitor visitor) {
        visitor.candidate("A String or CharSequence path").example("'src/main/java' or '/usr/include'");
        visitor.candidate("A String or CharSequence URI").example("'file:/usr/include'");
        visitor.candidate("A File instance.");
        visitor.candidate("A Path instance.");
        visitor.candidate("A Directory instance.");
        visitor.candidate("A RegularFile instance.");

        return false;
    }

    @Override
    public void explain(DiagnosticsVisitor visitor) {
        visitor.node(message);
        if (!locations.isEmpty()) {
            visitor.startChildren();
            for (String location : locations) {
                visitor.node(location);
            }
            visitor.endChildren();
        }
    }

    }

    @Override
    public FileTree visit(FileVisitor visitor) {
        tree.visit(visitor);
        return this;
    }

    @Override
    public void visitContentsAsFileTrees(Consumer<FileTreeInternal> visitor) {
        visitor.accept(this);
    }

    @Override
    protected void visitContents(FileCollectionStructureVisitor visitor) {

    }

    @Nullable
    @Override
    public HashCode getClassLoaderHash(ClassLoader classLoader) {
        Visitor visitor = new Visitor();
        visitor.visit(classLoader);
        return visitor.getHash();
    }

    private class Visitor extends ClassLoaderVisitor {
        private final Hasher hasher = Hashing.newHasher();
        private boolean foundUnknown;

        @Override

			}
		}
	}
	return true
}

// Visitor is called with each object name, and returns true if visiting should continue
type Visitor func(name string) (shouldContinue bool)

func skipEmptyNames(visitor Visitor) Visitor {
	return func(name string) bool {
		if len(name) == 0 {
			// continue visiting
			return true
		}
		// delegate to visitor
		return visitor(name)
	}
}

     */
    public void visitValues(String location, ValueVisitor<T> visitor) {
        VfsRelativePath relativePath = VfsRelativePath.of(location);
        if (relativePath.isEmpty()) {
            visitAllValues(visitor);
        } else {
            visitValuesRelatedTo(relativePath, visitor);
        }
    }

    /**

     */
    @Nullable Service getFactory(Class<?> type);

    /**
     * Collects all services of the given type.
     *
     * @return A visitor that should be used for all subsequent services.
     */
    Visitor getAll(Class<?> serviceType, Visitor visitor);

    interface Visitor {
        void visit(Service service);
    }

        return result;
    }

    @Override
    public void visit(Visitor visitor) {
        FileCollectionStructureVisitor.VisitType visitType = visitor.prepareForVisit(this);
        if (visitType == FileCollectionStructureVisitor.VisitType.NoContents) {
            visitor.visitArtifacts(new EndCollection(this));
            return;
        }

        // Calculate the artifacts now