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

        final Map<String, Object> requestBody = new HashMap<>();
        final String keyProp = NAME_PREFIX + id;
        requestBody.put(KEY_PROPERTY, keyProp);
        requestBody.put("replacement", "replacement" + id);
        requestBody.put("process_type", "C");
        requestBody.put("sort_order", id);
        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {

      return matcher.find();
    }

    @Override
    public boolean find(int index) {
      return matcher.find(index);
    }

    @Override
    public String replaceAll(String replacement) {
      return matcher.replaceAll(replacement);
    }

    @Override
    public int end() {
      return matcher.end();
    }

    @Override
    public int start() {
      return matcher.start();
    }
  }

                                    </tr>
                                    <tr>
                                        <th><la:message key="labels.replacement"/></th>
                                        <td>${f:h(replacement)}<la:hidden
                                                property="replacement"/></td>
                                    </tr>
                                    <tr>

    public void setReplacement_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setReplacement_Terms("replacement", opLambda, null);
    }

    public void setReplacement_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsPathMappingCA> aggsLambda) {
        setReplacement_Terms("replacement", opLambda, aggsLambda);
    }

        while (matcher.find()) {
            final String key = matcher.group(2);
            String replacement = System.getProperty(key);
            if (replacement == null) {
                replacement = matcher.group(1);
            }
            matcher.appendReplacement(tunedText, replacement.replace("\\", "\\\\").replace("$", "\\$"));

        }
        matcher.appendTail(tunedText);

    private List<Integer> pageNumberList;

    private int pageSize;

    private int currentPageNumber;

    public String id;

    public String regex;

    public String replacement;

    public String processType;

    public String sortOrder;

    public String createdBy;

    public String createdTime;

    public String versionNo;

    public void clear() {

            cb.query().setRegex_Wildcard(wrapQuery(pathMappingPager.regex));
        }
        if (StringUtil.isNotBlank(pathMappingPager.replacement)) {
            cb.query().setReplacement_Wildcard(wrapQuery(pathMappingPager.replacement));
        }
        // TODO Long, Integer, String supported only.

        // setup condition
        cb.query().addOrderBy_SortOrder_Asc();

    protected CIFSContext failHostInjecting ( CIFSContext ctx, final String replacement ) throws UnknownHostException {

        final NameServiceClient nscl = ctx.getNameServiceClient();

        final NameServiceClient wrapper = new DelegatingNameServiceClient(nscl) {

            private InetAddress replacementINET = InetAddress.getByName(replacement);
            private NetbiosAddress replacementNetbios = nscl.getNbtByName(replacement);

      return matcher.find();
    }

    @Override
    public boolean find(int index) {
      return matcher.find(index);
    }

    @Override
    public String replaceAll(String replacement) {
      return matcher.replaceAll(replacement);
    }

    @Override
    public int end() {
      return matcher.end();
    }

    @Override
    public int start() {
      return matcher.start();
    }
  }