*     key
   * @throws NullPointerException if any key or value in {@code map} is null
   */
  public static <K, V> ImmutableBiMap<K, V> copyOf(Map<? extends K, ? extends V> map) {
    if (map instanceof ImmutableBiMap) {
      @SuppressWarnings("unchecked") // safe since map is not writable
      ImmutableBiMap<K, V> bimap = (ImmutableBiMap<K, V>) map;
      // TODO(lowasser): if we need to make a copy of a BiMap because the

        return dictionaryManager.getDictionaryFile(dictId).filter(StopwordsFile.class::isInstance)
                .map(file -> OptionalEntity.of((StopwordsFile) file)).orElse(OptionalEntity.empty());
    }

    public OptionalEntity<StopwordsItem> getStopwordsItem(final String dictId, final long id) {
        return getStopwordsFile(dictId).map(file -> file.get(id).get());
    }

        return dictionaryManager.getDictionaryFile(dictId).filter(SynonymFile.class::isInstance)
                .map(file -> OptionalEntity.of((SynonymFile) file)).orElse(OptionalEntity.empty());
    }

    public OptionalEntity<SynonymItem> getSynonymItem(final String dictId, final long id) {
        return getSynonymFile(dictId).map(file -> file.get(id).get());
    }

    public void store(final String dictId, final SynonymItem synonymItem) {

    private List<ArtifactTransformation> artifactTransformations;

    @Inject
    public DefaultArtifactTransformationManager(Map<String, ArtifactTransformation> artifactTransformations) {
        this.artifactTransformations = Stream.of("release", "latest", "snapshot")
                .map(artifactTransformations::get)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    ConcurrentMap<String, AtomicInteger> map = new MapMaker().makeMap();
    multiset = ConcurrentHashMultiset.create(map);
    reserializeAndAssert(multiset);
  }

  public void testSerializationWithMapMaker2() {
    ConcurrentMap<String, AtomicInteger> map = new MapMaker().makeMap();
    multiset = ConcurrentHashMultiset.create(map);
    multiset.addAll(ImmutableList.of("a", "a", "b", "c", "d", "b"));

                    form.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                            .filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));
                    form.virtualHosts = stream(entity.getVirtualHosts())
                            .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining("\n")));

                    form.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                            .filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));
                    form.virtualHosts = stream(entity.getVirtualHosts())
                            .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining("\n")));

        final CrawlingConfig crawlingConfig = crawlingConfigHelper.get(crawlerContext.getSessionId());
        final Map<String, String> clientConfigMap = crawlingConfig.getConfigParameterMap(ConfigName.CLIENT);
        final String value = clientConfigMap.get(CRAWLER_CLIENTS);
        final CrawlerClient client = getClientRuleList(value).stream().map(e -> {
            if (e.getSecond().matcher(url).matches()) {
                return e.getFirst();

        final CrawlingInfoHelper crawlingInfoHelper = ComponentUtil.getCrawlingInfoHelper();
        final LanguageHelper languageHelper = ComponentUtil.getLanguageHelper();
        final List<Map<String, Object>> docList = body.documents.stream().map(doc -> {
            if (!doc.containsKey(indexFieldContentLength)) {
                long contentLength = 0;
                if (doc.get(indexFieldTitle) instanceof final String title) {

     * @throws IOException If the model could not be deserialized.
     * @throws ModelParseException If the input format could not be parsed.
     * @deprecated Use {@link #read(Path, Map)} instead.
     */
    @Deprecated
    Model read(File input, Map<String, ?> options) throws IOException, ModelParseException;

    /**
     * Reads the model from the specified file.
     *