if (pos == current) {
                newClientMap.put(Pattern.compile(regex), client);
                added = true;
            }
            newClientMap.put(entry.getKey(), entry.getValue());
            current++;
        }
        if (!added) {
            newClientMap.put(Pattern.compile(regex), client);
        }
        clientMap = newClientMap;
    }

    /**

    newFirst = segment.removeEntryFromChain(entryThree, entryOne);
    assertThat(newFirst.getKey()).isSameInstanceAs(keyTwo);
    assertThat(newFirst.getValueReference().get()).isSameInstanceAs(valueTwo);
    assertThat(newFirst.getHash()).isEqualTo(hashTwo);
    newFirst = newFirst.getNext();
    assertThat(newFirst.getKey()).isSameInstanceAs(keyThree);
    assertThat(newFirst.getValueReference().get()).isSameInstanceAs(valueThree);

                          return next.getValue();
                        }

                        @Override
                        public String getKey() {
                          return next.getKey();
                        }

                        @Override
                        public boolean equals(@Nullable Object obj) {
                          return next.equals(obj);

                final CrawlingInfoParam crawlingInfoParam = new CrawlingInfoParam();
                crawlingInfoParam.setCrawlingInfoId(crawlingInfo.getId());
                crawlingInfoParam.setKey(entry.getKey());
                crawlingInfoParam.setValue(entry.getValue());
                crawlingInfoParamList.add(crawlingInfoParam);
            }
            getCrawlingInfoService().storeInfo(crawlingInfoParamList);

            if (fieldConfigs.getConfig(e.getKey()).map(FieldConfigs.Config::isOverwrite).orElse(false)
                    && e.getValue() instanceof final Object[] values && values.length > 0) {
                newDataMap.put(e.getKey(), values[values.length - 1]);
            } else {
                newDataMap.put(e.getKey(), e.getValue());
            }
        }
        return newDataMap;
    }

        this.titleCell = titleCell
        this.valueCell = valueCell
    }

    @Override
    String toString() {
        return "attribute[key: $key, value: $valueCell.textContent]"
    }

    String getKey() {
        return titleCell.textContent
    }

    List<Node> getTitle() {
        return titleCell.childNodes.collect { it }
    }

    List<Node> getValue() {

            getWebConfig().getConfigParameterMap(ConfigName.CONFIG)
                    .entrySet()
                    .stream()
                    .filter(e -> e.getKey().startsWith(Config.JCIFS_PREFIX))
                    .forEach(e -> {
                        props.setProperty(e.getKey(), e.getValue());
                    });
            return new NTLMScheme(new JcifsEngine(props));
        }
        if (Constants.FORM.equals(scheme)) {

     *
     * @param key
     *            7 or 8 byte DES key
     * @return DES cipher in encryption mode
     */
    public static Cipher getDES(final byte[] key) {
        if (key.length == 7) {
            return getDES(des7to8(key));
        }

        try {
            final Cipher c = Cipher.getInstance("DES/ECB/NoPadding");

        }
        this.headerFields = null;
        for (final Entry<String, List<String>> property : this.connection.getRequestProperties().entrySet()) {
            final String key = property.getKey();
            final StringBuilder value = new StringBuilder();
            final Iterator<String> values = property.getValue().iterator();
            while (values.hasNext()) {
                value.append(values.next());

                    logger.warn("Could not parse a value of " + entry.getKey() + ":" + entry.getValue(), e);
                }
                if (nodeStrList.size() == 1) {
                    buf.append(getResultDataBody(entry.getKey(), nodeStrList.get(0)));
                } else if (nodeStrList.size() > 1) {
                    buf.append(getResultDataBody(entry.getKey(), nodeStrList));
                }
            }