import org.gradle.internal.component.model.ComponentOverrideMetadata
import org.gradle.internal.component.model.ImmutableModuleSources
import org.gradle.internal.hash.Hashing
import org.gradle.internal.resolve.result.BuildableArtifactFileResolveResult
import org.gradle.internal.resolve.result.DefaultBuildableArtifactSetResolveResult

	// specific values. See the documentation in each package for details.
	//
	// Note that when a signature of a hash of a larger message is needed,
	// the caller is responsible for hashing the larger message and passing
	// the hash (as digest) and the hash function (as opts) to Sign.
	Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
}

		return ErrVerification
	}
	return nil
}

// signPSSWithSalt calculates the signature of hashed using PSS with specified salt.
// Note that hashed must be the result of hashing the input message using the
// given hash function. salt is a random sequence of bytes whose length will be
// later used to verify the signature.

    enum SupportedHash {
        SHA1, SHA256, SHA512, MD5
    }

    enum EtagStrategy {
        NONE({ null }),
        RAW_SHA1_HEX({ Hashing.sha1().hashBytes(it as byte[]).toString() }),
        NEXUS_ENCODED_SHA1({ "{SHA1{" + Hashing.sha1().hashBytes(it as byte[]) + "}}" })

        private final Closure generator

        EtagStrategy(Closure generator) {
            this.generator = generator

import com.google.common.annotations.VisibleForTesting;

/**
 * Implementation of FarmHash Fingerprint64, an open-source fingerprinting algorithm for strings.
 *
 * <p>Its speed is comparable to CityHash64, and its quality of hashing is at least as good.
 *
 * <p>Note to maintainers: This implementation relies on signed arithmetic being bit-wise equivalent
 * to unsigned arithmetic in all cases except:
 *
 * <ul>

import com.google.common.annotations.VisibleForTesting;

/**
 * Implementation of FarmHash Fingerprint64, an open-source fingerprinting algorithm for strings.
 *
 * <p>Its speed is comparable to CityHash64, and its quality of hashing is at least as good.
 *
 * <p>Note to maintainers: This implementation relies on signed arithmetic being bit-wise equivalent
 * to unsigned arithmetic in all cases except:
 *
 * <ul>

					"testing-jvm",
					"worker-main",
					"files",
					"stdlib-java-extensions",
					"build-cache-packaging",
					"build-operations",
					"precondition-tester",
					"tooling-api-builders",
					"hashing",
					"base-services-groovy",
					"kotlin-dsl-provider-plugins"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"plugin-use",

};

/// Hashing infrastructure for Tuple.
inline size_t TaggedValueHash<Tuple>::operator()(const Tuple& t) const {
  std::size_t hash = 0;
  for (auto& i : t) {
    hash ^= TaggedValueHash<TaggedValue>()(i);
  }
  return hash;
}

/// @brief The TaggedValueHashVisitor class for doing type-based hashing
/// of TaggedValues.
class TaggedValueHashVisitor {
 public:

    api(project(":execution"))
    api(project(":file-collections"))
    api(project(":file-temp"))
    api(project(":file-watching"))
    api(project(":files"))
    api(project(":functional"))
    api(project(":hashing"))
    api(project(":internal-instrumentation-api"))
    api(project(":jvm-services"))
    api(project(":logging"))
    api(project(":logging-api"))
    api(project(":messaging"))
    api(project(":model-core"))

    api(project(":enterprise-logging"))
    api(project(":execution"))
    api(project(":file-collections"))
    api(project(":file-watching"))
    api(project(":files"))
    api(project(":hashing"))
    api(projects.instrumentationAgentServices)
    api(project(":stdlib-java-extensions"))
    api(project(":jvm-services"))
    api(project(":logging"))
    api(project(":logging-api"))
    api(project(":messaging"))