return Collections.unmodifiableList(asStripes);
  }

  // Static factories

  /**
   * Creates a {@code Striped<L>} with eagerly initialized, strongly referenced locks. Every lock is
   * obtained from the passed supplier.
   *
   * @param stripes the minimum number of stripes (locks) required
   * @param supplier a {@code Supplier<L>} object to obtain locks from

        then:
        projectDependencies.size() == numberOfProjects
        projectDependencies.keySet().every { it >= 1 && it <= numberOfProjects }
        projectDependencies.values().every { dependencyList -> dependencyList.every { it >= 1 && it <= numberOfProjects } }
        projectDependencies == projectDependencies2

        where:
        num  | distribution
        1    | [1]

        when:
        def featuresText = featuresFile.text

        then:
        def lines = featuresText.readLines()
        lines.size() <= 10
        lines.every { it.startsWith(" - ") || it.startsWith("   - ")}
        lines.every { it.length() <= 80 }
    }

 * message bus adds too much overhead.
 */
public abstract class KotlinModificationTrackerFactory : KotlinPlatformComponent {
    /**
     * Creates an out-of-block modification tracker which is incremented every time there is an out-of-block change in some source project
     * module.
     *
     * ### Out-of-block Modification (OOBM)
     *

 *
 * @since 8.0
 */
@HasInternalProtocol
@Incubating
public interface Cleanup {
    /**
     * Perform cache cleanup after every build session.
     */
    Cleanup ALWAYS = new DefaultCleanup(CleanupFrequency.ALWAYS);

    /**
     * Perform cache cleanup periodically (default is only once every 24 hours).
     */
    Cleanup DEFAULT = new DefaultCleanup(CleanupFrequency.DAILY);

    /**
     * Never perform cache cleanup.

        implementation project(':common')
    }
}
// end::cpp-dependency-mgmt[]

// tag::cpp-compiler-options-all-variants[]
tasks.withType(CppCompile).configureEach {
    // Define a preprocessor macro for every binary
    macros.put("NDEBUG", null)

    // Define a compiler options
    compilerArgs.add '-W3'

    // Define toolchain-specific compiler options
    compilerArgs.addAll toolChain.map { toolChain ->

    // Define a preprocessor macro for every binary
    macros.add("NDEBUG")

    // Define a compiler options
    compilerArgs.add("-O")
}
// end::swift-compiler-options-all-variants[]

// tag::swift-compiler-options-per-variants[]
application {
    binaries.configureEach(SwiftStaticLibrary::class.java) {
        // Define a preprocessor macro for every binary
        compileTask.get().macros.add("NDEBUG")

package sync

// OnceFunc returns a function that invokes f only once. The returned function
// may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceFunc(f func()) func() {
	var (
		once  Once
		valid bool
		p     any
	)
	// Construct the inner closure just once to reduce costs on the fast path.
	g := func() {
		defer func() {

        given:
        def table = new StyledTable(
            "",
            ["Very Long"],
            [
                new StyledTable.Row(["foo"], StyledTextOutput.Style.Normal)
            ]
        )

        expect:
        StyledTableUtil.toString(table) == """
            | Very Long |
            |-----------|
            | foo       |
        """.stripIndent(true).trim()
    }

    }
}
// end::cpp-dependency-mgmt[]

// tag::cpp-compiler-options-all-variants[]
tasks.withType(CppCompile::class.java).configureEach {
    // Define a preprocessor macro for every binary
    macros.put("NDEBUG", null)

    // Define a compiler options
    compilerArgs.add("-W3")

    // Define toolchain-specific compiler options
    compilerArgs.addAll(toolChain.map { toolChain ->