private void fireEvent(int event, List<ResolutionListener> listeners, ResolutionNode node, Artifact replacement) {
        fireEvent(event, listeners, node, replacement, null);
    }

    private void fireEvent(
            int event,
            List<ResolutionListener> listeners,
            ResolutionNode node,
            Artifact replacement,
            VersionRange newRange) {
        for (ResolutionListener listener : listeners) {

    public void setReplacement_Equal(String replacement) {
        setReplacement_Term(replacement, null);
    }

    public void setReplacement_Equal(String replacement, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setReplacement_Term(replacement, opLambda);
    }

    public void setReplacement_Term(String replacement) {
        setReplacement_Term(replacement, null);
    }

  /**
   * Creates a new ArrayBasedUnicodeEscaper instance with the given replacement map and specified
   * safe range. If {@code safeMax < safeMin} then no code points are considered safe. This
   * initializer is useful when explicit instances of ArrayBasedEscaperMap are used to allow the
   * sharing of large replacement mappings.
   *
   * <p>If a code point has no mapped replacement then it is checked against the safe range. If it

    public void updateScope(Artifact artifact, String scope) {}

    @Override
    public void manageArtifact(Artifact artifact, Artifact replacement) {}

    @Override
    public void selectVersionFromRange(Artifact artifact) {}

    @Override
    public void restrictRange(Artifact artifact, Artifact replacement, VersionRange newRange) {}

        this.regex = value;
    }

    public String getReplacement() {
        checkSpecifiedProperty("replacement");
        return convertEmptyToNull(replacement);
    }

    public void setReplacement(String value) {
        registerModifiedProperty("replacement");
        this.replacement = value;
    }

    public Integer getSortOrder() {
        checkSpecifiedProperty("sortOrder");

    for (; index < slen; index++) {

      // Get a replacement for the current character.
      char[] r = escape(s.charAt(index));

      // If no replacement is needed, just continue.
      if (r == null) {
        continue;
      }

      int rlen = r.length;
      int charsSkipped = index - lastEscape;

      // This is the size needed to add the replacement, not the full size

            if (matchUserAgent(pathMapping)) {
                String replacement = pathMapping.getReplacement();
                if (replacement == null) {
                    replacement = StringUtil.EMPTY;
                }
                result = result.replaceAll("(\"[^\"]*)" + pathMapping.getRegex() + "([^\"]*\")", "$1" + replacement + "$2");
            }
        }
        return result;
    }

    /**

    void omitForNearer(Artifact omitted, Artifact kept);

    void updateScope(Artifact artifact, String scope);

    @Deprecated
    void manageArtifact(Artifact artifact, Artifact replacement);

    // TODO Remove ResolutionListenerDM interface

    void omitForCycle(Artifact artifact);

    /**

     *
     * @param target The target string.
     * @param replacement The replacement string.
     */
    public void add(final String target, final String replacement) {
        if (target == null || replacement == null) {
            throw new CrawlerSystemException("Target or replacement cannot be null.");
        }
        convertMap.put(target, replacement);
    }

    /**
     * Sets the conversion map.

     * Default constructor.
     */
    public SearchBody() {
        super();
    }

    /** Regular expression pattern for path mapping */
    public String regex;

    /** Replacement pattern for path mapping */
    public String replacement;