// so we have to collect also transitive super types
        return directSuperTypes.map {
            it.key to computeAllSuperTypes(it.key, directSuperTypes)
        }.toMap()
    }

    private
    fun computeAllSuperTypes(className: String, directSuperTypes: Map<String, Set<String>>): Set<String> {
        val superTypes: Queue<String> = ArrayDeque(directSuperTypes[className] ?: emptySet())

     * System scope.
     */
    SYSTEM("system", false);

    private static final Map<String, DependencyScope> IDS = Collections.unmodifiableMap(
            Stream.of(DependencyScope.values()).collect(Collectors.toMap(s -> s.id, s -> s)));

    public static DependencyScope forId(String id) {
        return IDS.get(id);
    }

    private final String id;
    private final boolean transitive;

        this.types = nonNull(providers, "providers").stream()
                .flatMap(p -> p.provides().stream())
                .collect(Collectors.toMap(Type::id, identity()));
        this.languageRegistry = nonNull(languageRegistry, "languageRegistry");
        this.usedTypes = new ConcurrentHashMap<>();
        this.manager = nonNull(manager, "artifactHandlerManager");
    }

	if len(f.cachedTags) == 0 {
		return true
	}

	parsedTags, err := tags.ParseObjectTags(userTags)
	if err != nil {
		return false
	}

	tagsMap := parsedTags.ToMap()

	// This filter has tags configured but this object
	// does not have any tag, skip this object
	if len(tagsMap) == 0 {
		return false
	}

	// Both filter and object have tags, find a match,

            val allSubstitutors = buildList {
                combinations.forEach { typesPermutation ->
                    add(buildSubstitutor { substitutions(typeParameters.zip(typesPermutation).toMap()) })
                }
            }

            allSubstitutors.forEach { substitutor ->
                testContractsOnDeclarationSymbol(symbol, substitutor, testServices)
            }
        }
    }

            coll.add(item);
        }
        return coll;
    }

    /**
     * Wraps the given key and value in a mutable unordered map.
     */
    public static <K, V> Map<K, V> toMap(K key, V value) {
        logDeprecation(7);
        Map<K, V> map = new HashMap<K, V>();
        map.put(key, value);
        return map;
    }

    @SafeVarargs
    @SuppressWarnings("varargs")

    private void hashManifestAttributes(Attributes attributes, String name, Hasher hasher) {
        Map<String, String> entries = attributes
            .entrySet()
            .stream()
            .collect(Collectors.toMap(
                entry -> entry.getKey().toString().toLowerCase(Locale.ROOT),
                entry -> (String) entry.getValue()
            ));
        List<Map.Entry<String, String>> normalizedEntries = entries.

	}
}

func formatIDMappings(idMap []SysProcIDMap) []byte {
	var data []byte
	for _, im := range idMap {
		data = append(data, itoa.Itoa(im.ContainerID)+" "+itoa.Itoa(im.HostID)+" "+itoa.Itoa(im.Size)+"\n"...)
	}
	return data
}

// writeIDMappings writes the user namespace User ID or Group ID mappings to the specified path.
func writeIDMappings(path string, idMap []SysProcIDMap) error {

    }

    public Map<MavenProject, ProjectSegment> selectSegment(TaskSegment taskSegment) {
        return items.stream()
                .filter(pb -> taskSegment == pb.getTaskSegment())
                .collect(Collectors.toMap(ProjectSegment::getProject, Function.identity()));
    }

    /**
     * Finds the first ProjectSegment matching the supplied project
     * @param mavenProject the requested project

            allElements.addAll(projectToInformationMap.values());

            this.deduplicated = deduplicator.deduplicate(allElements).entrySet().stream()
                .collect(Collectors.toMap(e -> e.getKey().project, Map.Entry::getValue));
        }
        return deduplicated;
    }

    private static class ProjectStateWrapper {
        private final String name;