.directory(sourceRoot.directory().toString())
                .includes(sourceRoot.includes())
                .excludes(sourceRoot.excludes())
                .filtering(Boolean.toString(sourceRoot.stringFiltering()))
                .targetPath(sourceRoot.targetPath().map(Path::toString).orElse(null))
                .build());
        this.originalSourceRoot = sourceRoot;

    private final List<Pair<String, String>> searchFieldLogList = new ArrayList<>();

    private final List<Pair<String, String>> headerList = new ArrayList<>();

    private OptionalEntity<UserInfo> userInfo;

    private Map<String, Object> fields;

    private final List<Map<String, Object>> documentList = new ArrayList<>();

    @Override
    public String getId() {
        return asDocMeta().id();
    }

    protected Map<String, String> handlerParameterMap;

    protected Map<String, String> handlerScriptMap;

    protected CrawlerClientFactory crawlerClientFactory = null;

    protected Map<ConfigName, Map<String, String>> configParameterMap;

    public DataConfig() {
        setBoost(1.0f);
    }

    @Override
    public String getDocumentBoost() {
        return getBoost().toString();

    }

    private Map<String, Object> maskContext(Map<String, Object> context) {
        if (!maskSensitiveData) {
            return context;
        }

        Map<String, Object> masked = getContextMap();
        for (Map.Entry<String, Object> entry : context.entrySet()) {
            String key = entry.getKey().toLowerCase();
            Object value = entry.getValue();

    }

  fun addHeader(header: String) =
    apply {
      headersBuilder.add(header)
    }

  fun addHeader(
    name: String,
    value: Any,
  ) = apply {
    headersBuilder.add(name, value.toString())
  }

  fun addHeaderLenient(
    name: String,
    value: Any,
  ) = apply {
    addHeaderLenient(headersBuilder, name, value.toString())
  }

  fun setHeader(

     * @param pattern
     *            The pattern string
     * @return The converted {@literal double}
     */
    public static double toPrimitiveDouble(final Object o, final String pattern) {
        if (o == null) {
            return 0;
        } else if (o instanceof Number) {
            return ((Number) o).doubleValue();
        } else if (o instanceof String) {
            return toPrimitiveDouble((String) o);

/**
 * Microbenchmark for {@link Splitter#on} with char vs String with length == 1.
 *
 * @author Paul Lindner
 */
@NullUnmarked
public class SplitterBenchmark {
  // overall size of string
  @Param({"1", "10", "100", "1000"})
  int length;

  // Number of matching strings
  @Param({"xxxx", "xxXx", "xXxX", "XXXX"})
  String text;

  private String input;

    }

    private static String unQuoteUnEscape(final String original) {
        String result = original;

        // Unquote
        if (result.indexOf('\"') >= 0) {
            final Matcher m = QUOTE_REPLACE_PATTERN.matcher(original);
            if (m.matches()) {
                result = m.group(1);
            }

            // Unescape
            if (result.indexOf(ESCAPED_QUOTE) >= 0) {

    // ---------------------------------------------------------------------
    @Override
    public String toString() {
        return "[" + (md == null ? "no metadata" : md.toString()) + "]";
    }

    // ---------------------------------------------------------------------
    private static int compareStrings(String s1, String s2) {
        if (s1 == null && s2 == null) {
            return 0;
        }

     * @param pattern
     *            The pattern string
     * @return The converted {@link Integer}
     */
    public static Integer toInteger(final Object o, final String pattern) {
        return switch (o) {
        case null -> null;
        case Integer i -> i;
        case Number n -> n.intValue();
        case String s -> toInteger(s);