* limitations under the License.
 */
rootProject.name = 'platform'

dependencyResolutionManagement {
    versionCatalogs {
        libs {
            library('mylib', 'org:mylib:1.0')
        }
    }

 * limitations under the License.
 */

// tag::platform_uses_catalog[]
plugins {
    `java-platform`
}

dependencies {
    constraints {
        api(libs.mylib)
    }
}

 * limitations under the License.
 */
rootProject.name = "platform"

dependencyResolutionManagement {
    versionCatalogs {
        create("libs") {
            library("mylib", "org:mylib:1.0")
        }
    }

        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.candidate("Map with mandatory 'library' and optional 'project' and 'linkage' keys").example("[project: ':someProj', library: 'mylib', linkage: 'static']");
        }

        @SuppressWarnings("unused")
        protected NativeLibraryRequirement parseMap(
            @MapKey("library") String libraryName,

				// allow #pragma dynimport _ _ "foo.so"
				// to force a link of foo.so.
				havedynamic = 1

				if ctxt.HeadType == objabi.Hdarwin {
					machoadddynlib(lib, ctxt.LinkMode)
				} else {
					dynlib = append(dynlib, lib)
				}
				continue
			}

			q := ""
			if before, after, found := strings.Cut(remote, "#"); found {
				remote, q = before, after
			}
			s := l.LookupOrCreateSym(local, 0)

        result.projectPath == projectPath
        result.libraryName == libraryName

        where:
        projectPath | libraryName
        ':myPath'   | null
        ':myPath'   | 'myLib'
        ':myPath'   | null
        ':myPath'   | 'myLib'
    }

    def "serializes version constraint"() {
        given:

class ResolvableConfigurationsReportTaskIntegrationTest extends AbstractIntegrationSpec implements InspectsConfigurationReport {
    def setup() {
        settingsFile << """
            rootProject.name = "myLib"
        """
    }

    def "if no configurations present in project, task reports complete absence"() {
        expect:
        succeeds ':resolvableConfigurations'

        }

        return sequenceOf(directory)
    }

    private
    fun aJar(sourceFiles: Sequence<Path>): Sequence<Path> {
        val outputPath = projectDir.resolve("mylib.jar")
        Files.newOutputStream(outputPath).use { outputStream ->
            JarOutputStream(outputStream).use { jarStream ->
                sourceFiles.forEach { dir ->

        project.group = 'my.group'
        project.library.baseName = 'mylib'
        project.evaluate()

        then:
        def publishing = project.publishing
        publishing.publications.size() == 3

        def main = publishing.publications.main
        main.groupId == 'my.group'
        main.artifactId == 'mylib'
        main.version == '1.2'
        main.artifacts.size() == 1

The typical example is that using a single dependency declaration `project(":myLib")`, we would either choose the `arm64` or `i386` version of `myLib` depending on the architecture.

To do this, we will add attributes to both the consumer and the producer.

--