@Override
        public String getName(ProjectState element) {
            return element.getName();
        }

        @Override
        public String getIdentityName(ProjectState element) {
            String identityName = element.getIdentityPath().getName();
            return identityName != null ? identityName : element.getName();
        }

        @Override

            throw new InvalidIvyPublicationException(publication.getName(), pe.getLocalizedMessage(), pe);
        }
    }

    private void validateArtifacts(IvyNormalizedPublication publication) {
        for (final IvyArtifact artifact : publication.getAllArtifacts()) {
            field(publication, "artifact name", artifact.getName())
                    .notEmpty().validInFileName();

                identifier = ResolvedCoordinates.create(dependency.getGroup(), dependency.getName(), null);
            }
            return moduleDependencyCoordinatesFor(identifier, ((ExternalDependency) dependency).getVersionConstraint());
        } else {
            throw new UnsupportedOperationException("Unsupported dependency type: " + dependency.getClass().getName());
        }
    }

                    getDisplayName(), publicType.getName()), name, publicType);
        } else if (publicType != null) {
            return new MissingPropertyException(String.format("Could not get unknown property '%s' for object of type %s.", name,
                    publicType.getName()), name, publicType);
        } else {
            // Use the display name anyway

                binaries.add(new DefaultCppExecutableModel(binary.getName(), cppBinary.getIdentity().getName(), binary.getBaseName().get(), compilationDetails, linkageDetails));
            } else if (binary instanceof CppSharedLibrary) {
                CppSharedLibrary sharedLibrary = (CppSharedLibrary) binary;

        BinaryNamingScheme namingScheme = DefaultBinaryNamingScheme.component(library.getName())
                .withBinaryType(typeName)
                .withVariantDimension(platform.getName())
                .withVariantDimension(buildType.getName())
                .withVariantDimension(flavor.getName());
        return namingScheme.getBinaryName();
    }

    public static UnresolvableConfigurationResult of(Configuration configuration) {
        return new UnresolvableConfigurationResult(
            configuration.getClass().getName() + configuration.hashCode(),
            configuration.getName(),
            unresolvableChildren(configuration)
        );
    }

    @SuppressWarnings("deprecation")

            if (type == null) {
                throw new IllegalArgumentException(String.format("Artifact type %s is not registered for component type %s.", artifact.getName(), componentType.getName()));
            }
            return type;
        }

        @Override
        public ComponentTypeRegistration registerArtifactType(Class<? extends Artifact> artifact, ArtifactType artifactType) {

                dist.getDistributionBaseName().convention(project.getName());
            } else {
                zipTaskName = dist.getName() + "DistZip";
                tarTaskName = dist.getName() + "DistTar";
                installTaskName = "install" + StringUtils.capitalize(dist.getName()) + "Dist";
                assembleTaskName = "assemble" + StringUtils.capitalize(dist.getName()) + "Dist";

		AddFunc: func(obj controllers.Object) {
			tracker.Record("add/" + obj.GetName())
		},
		UpdateFunc: func(oldObj, newObj controllers.Object) {
			tracker.Record("update/" + newObj.GetName())
		},
		DeleteFunc: func(obj controllers.Object) {
			tracker.Record("delete/" + obj.GetName())
		},
	}
}

func Names[T controllers.Object](list []T) sets.String {