roleTypeList.add(systemHelper.getSearchRoleByGroup(groupPrincipal.getName()));
                        } else if (principal != null) {
                            roleTypeList.add(systemHelper.getSearchRoleByUser(principal.getName()));
                        }
                    });
                } else if (fileAttributeView instanceof final PosixFileAttributeView posixFileAttributeView) {

                        responseData.setMimeType(mimeTypeHelper.getContentType(is, file.getName()));
                    } catch (final Exception e) {
                        responseData.setMimeType(mimeTypeHelper.getContentType(null, file.getName()));
                    }

                    if (contentLengthHelper != null) {

        for (ProjectLibrary newLibrary : newLibraries) {
            String originalName = newLibrary.getName();
            int suffix = 1;
            while (containsLibraryWithSameName(existingLibraries, newLibrary.getName())) {
                newLibrary.setName(originalName + "-" + suffix++);
            }
            existingLibraries.add(newLibrary);
        }
    }

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

            try {
                downloadObject(getObjectName(pi.getPath(), pi.getName()), out);
            } catch (final StorageException e) {
                logger.warn("Failed to download {}", pi.getName(), e);
                throwValidationError(messages -> messages.addErrorsStorageFileDownloadFailure(GLOBAL, pi.getName()),
                        () -> asListHtml(encodeId(pi.getPath())));
            }
        });

        this.operation = operation;
    }

    @Override
    public String getId() {
        return delegate.getId();
    }

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

    @Override
    public ModuleComponentRepositoryAccess<ModuleComponentGraphResolveState> getLocalAccess() {
        return localAccess;
    }

    @Override

                return;
            }
            if (consumerValue.getName().equals(Usage.JAVA_API)) {
                if (COMPATIBLE_WITH_JAVA_API.contains(producerValue.getName())) {
                    details.compatible();
                }
                return;
            }
            if (consumerValue.getName().equals(Usage.JAVA_RUNTIME) && producerValue.getName().equals(DEPRECATED_JAVA_RUNTIME_JARS)) {

                        final int i = getName().length();
                        setSerializableSupplier(() -> i);
                        setNonSerializableSupplier(() -> i);
                    }

                    public void setInstanceCapturingLambda() {
                        setSerializableSupplier(() -> getName().length());
                        setNonSerializableSupplier(() -> getName().length());
                    }

        if (alreadyAssessed.add(attribute.getName())) {
            Attribute<Object> untyped = Cast.uncheckedCast(attribute);
            String attributeName = attribute.getName();
            AttributeValue<?> consumerValue = requestedAttributes.findEntry(attributeName);

                    warnings.addVariantUnsupported(String.format("Declares capability %s:%s:%s which cannot be mapped to Maven", capability.getGroup(), capability.getName(), capability.getVersion()));
                }
            }
        }

        return new ParsedVariantDependencyResult(variant.getName(), dependencies, platforms, constraints, warnings);
    }