final Map<String, Pair<Map<String, String>, List<Pair<Pattern, String>>>> relatedContentMap = new HashMap<>();
        getAvailableRelatedContentList().stream().forEach(entity -> {
            final String key = getHostKey(entity);
            Pair<Map<String, String>, List<Pair<Pattern, String>>> pair = relatedContentMap.get(key);
            if (pair == null) {
                pair = new Pair<>(new HashMap<>(), new ArrayList<>());

        }
        return pairs;
    }

    /**
     * Checks if the AV pairs list contains a pair of the specified type
     *
     * @param pairs the list of AV pairs to search
     * @param type the AV pair type to look for
     * @return whether the list contains a pair of that type
     */
    public static boolean contains(final List<AvPair> pairs, final int type) {
        if (pairs == null) {

            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> isAttribute(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

    // Returns -1 if the DOS code is not mapped.
    private static int findNtStatusOrMinusOne(int dosCode) {
        for (int[] pair : DosError.DOS_ERROR_CODES) {
            // each pair is [dosCode, ntStatus]
            if (pair != null && pair.length == 2 && pair[0] == dosCode) {
                return pair[1];
            }
        }
        return -1;
    }

        assertEquals(1, pairs.size(), "Should have decoded one pair");

        AvPair pair = pairs.get(0);
        assertEquals(AvPair.MsvAvFlags, pair.getType(), "Pair type should be MsvAvFlags");
        assertTrue(pair instanceof AvFlags, "Should be decoded as AvFlags");
        assertEquals(0x12345678, ((AvFlags) pair).getFlags(), "Flags value should match");
    }

    /**

            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> !"name".equals(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

                    }
                    configPasswordMap.put(value, list);
                }
                for (final Pair<Pattern, String> pair : list) {
                    if (pair.getFirst().matcher(url).matches()) {
                        return pair.getSecond();
                    }
                }
            }
        }

        return null;
    }

    // you can adjust your actions by overriding
    // default methods defined at the interface
    // _/_/_/_/_/_/_/_/_/_/

    protected Map<String, List<Pair<String, String>>> responseHeaderMap = new HashMap<>();

    protected List<Pair<String, String>> defaultResponseHeaders;

    public FessActionAdjustmentProvider(final FessConfig fessConfig) {
        parseResponseHeaderConfig(fessConfig.getResponseHeaders());
    }

         * @param field the field name to split
         * @return a Pair containing the field name and extension key
         */
        protected Pair<String, String> splitField(final String defaultField, final String field) {
            final int indexOf = field.indexOf(':');
            if (indexOf < 0) {
                return new Pair<>(field, null);
            }

        final String[] pairs = queryString.split("&");
        try {
            for (final String pair : pairs) {
                final int pos = pair.indexOf('=');
                if (pos >= 0) {
                    final String key = urlCodec.decode(pair.substring(0, pos), enc);
                    List<String> list = paramListMap.get(key);
                    if (list == null) {