// the current time on its channel after at least duration d.
//
// Before Go 1.23, the garbage collector did not recover
// timers that had not yet expired or been stopped, so code often
// immediately deferred t.Stop after calling NewTimer, to make
// the timer recoverable when it was no longer needed.
// As of Go 1.23, the garbage collector can recover unreferenced
// timers, even if they haven't expired or been stopped.

  // NOLINTNEXTLINE: Use tsl::protobuf to be compatible with OSS.
  tsl::protobuf::TextFormat::Parser parser;
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);
  return hlo_proto->ParseFromString(contents) ||
         parser.ParseFromString(contents, hlo_proto) ||
         hlo_proto->mutable_hlo_module()->ParseFromString(contents) ||

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// GC checkmarks
//
// In a concurrent garbage collector, one worries about failing to mark
// a live object due to mutations without write barriers or bugs in the
// collector implementation. As a sanity check, the GC has a 'checkmark'
// mode that retraverses the object graph with the world stopped, to make

plugins {
    id("gradlebuild.distribution.packaging")
}

description = "The collector project for the 'jvm' portion of the Gradle distribution"

dependencies {
    coreRuntimeOnly(platform(project(":core-platform")))

    agentsRuntimeOnly(project(":instrumentation-agent"))

    pluginsRuntimeOnly(platform(project(":distributions-basics")))

    pluginsRuntimeOnly(project(":base-ide-plugins"))
    pluginsRuntimeOnly(project(":code-quality"))

plugins {
    id("gradlebuild.distribution.packaging")
}

description = "The collector project for the 'basics' portion of the Gradle distribution"

dependencies {
    coreRuntimeOnly(platform(project(":core-platform")))

    agentsRuntimeOnly(project(":instrumentation-agent"))

    pluginsRuntimeOnly(platform(project(":distributions-core")))

    pluginsRuntimeOnly(project(":resources-http"))
    pluginsRuntimeOnly(project(":resources-sftp"))

plugins {
    id("gradlebuild.distribution.packaging")
    id("gradlebuild.verify-build-environment")
    id("gradlebuild.install")
}

description = "The collector project for the entirety of the Gradle distribution"

dependencies {
    coreRuntimeOnly(platform(project(":core-platform")))

    agentsRuntimeOnly(project(":instrumentation-agent"))

    pluginsRuntimeOnly(platform(project(":distributions-publishing")))

            if (gradle.parent == null) {
                def collector = gradle.sharedServices.registerIfAbsent("originsCollector", OriginCollector) {
                    parameters.originJson.fileValue(new File("${TextUtil.normaliseFileSeparators(file.absolutePath)}"))
                }
                gradle.services.get(${BuildEventListenerRegistryInternal.name}).onOperationCompletion(collector)
            }
        """
    }

    @Override

    @ServiceScope(Scope.Global.class)
    class Collector {
        private final AtomicLong hashedFileCount = new AtomicLong();
        private final AtomicLong hashedContentLength = new AtomicLong();

        public void reportFileHashed(long length) {
            hashedFileCount.incrementAndGet();
            hashedContentLength.addAndGet(length);
        }

        public FileHasherStatistics collect() {

	for _, f := range fs {
		files = append(files, f)
	}
	return files
}

type collector struct {
	dirs  []string
	regex *regexp.Regexp
}

// handlePath walks the filesystem recursively, collecting directories,
// ignoring some unneeded directories (hidden/vendored) that are handled
// specially later.
func (c *collector) handlePath(path string, info os.FileInfo, err error) error {
	if err != nil {
		return err

    Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer);

    Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);

    MapSupplier<K, V> plus(MapCollector<K, V> collector);

    /**
     * Returns a view of this supplier that may calculate its value as empty if it would be missing.
     */
    MapSupplier<K, V> absentIgnoring();