"color": "red",
                "value": 80
              }
            ]
          },
          "unit": "none"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "available 10.13.1.25:9000"
            },
            "properties": [
              {
                "id": "color",
                "value": {

        return Base64.getUrlEncoder().encodeToString(path.getBytes(Constants.CHARSET_UTF_8));
    }

    protected boolean isTarget(final String path) {
        return pattern.matcher(path).find();
    }

    protected abstract DictionaryFile<? extends DictionaryItem> newDictionaryFile(String id, String path, Date timestamp);

                  },
                  "showPoints": "never"
               },
               "unit": "bytes"
            },
            "overrides": [
               {
                  "matcher": {
                     "id": "byRegexp",
                     "options": "/(virtual|resident)/i"
                  },
                  "properties": [
                     {

        if (c.name.startsWith("java.")) {
            return false
        } else if (c.name.contains('.internal.')) {
            return true
        } else {
            return !publicApiPatterns.any { it.matcher(c.name).find() }
        }
    }

        Predicate<Artifact> predGroupId = a -> groupId.matches(createPathProxy(a.getGroupId()));
        Predicate<Artifact> predArtifactId = a -> artifactId.matches(createPathProxy(a.getArtifactId()));
        return predGroupId.and(predArtifactId);
    }

    /**
     * In order to reuse the glob matcher from the filesystem, we need

        }

        int maxUaLength = -1;
        Directive matchedDirective = null;
        for (final Map.Entry<Pattern, Directive> entry : directiveMap.entrySet()) {
            if (entry.getKey().matcher(target).find()) {
                final Directive directive = entry.getValue();
                final String ua = directive.getUserAgent();
                int uaLength = 0;
                if (!ALL_BOTS.equals(ua)) {

        metadata.merge(new Metadata());

        String dateAfter = gregorianDate();

        String ts = metadata.metadata.getVersioning().getSnapshot().getTimestamp();
        String datePart = DATE_FILTER.matcher(ts).replaceAll("");

        /* Allow for this test running across midnight */
        Set<String> expected = new HashSet<>(Arrays.asList(dateBefore, dateAfter));

    private static int getRelationOrder(String value, RangeValue rangeValue, boolean isLeft) {
        if (rangeValue.value.isEmpty()) {
            return isLeft ? 1 : -1;
        }

        value = FILTER_1.matcher(value).replaceAll("");

        List<String> valueTokens = new ArrayList<>(Arrays.asList(FILTER_2.split(value)));
        List<String> rangeValueTokens = new ArrayList<>(Arrays.asList(FILTER_3.split(rangeValue.value)));

        if (StringUtil.isNotBlank(regex)) {
            final Pattern pattern = Pattern.compile(regex);
            System.getProperties().keySet().stream().filter(k -> k != null && pattern.matcher(k.toString()).matches())
                    .forEach(k -> addSystemProperty(cmdList, k.toString(), null, null));
        }
    }

    protected void deleteTempDir(final File ownTmpDir) {
        if (ownTmpDir == null) {

    This PR fixes a security issue where an IAM user based
    on his policy is granted more privileges than restricted
    by the users IAM policy.

    This is due to an issue of prefix based Matcher() function
    which was incorrectly matching prefix based on resource
    prefixes instead of exact match.
```