return Constants.TRUE;
        }

        for (final Pattern pattern : includedDocPathPatterns) {
            if (pattern.matcher(input).matches()) {
                return Constants.TRUE;
            }
        }

        for (final Pattern pattern : excludedDocPathPatterns) {
            if (pattern.matcher(input).matches()) {
                return Constants.FALSE;
            }
        }

     * @param pattern
     *            The pattern string
     * @return The converted {@literal int}
     */
    public static int toPrimitiveInt(final Object o, final String pattern) {
        return switch (o) {
        case null -> 0;
        case Number n -> n.intValue();
        case String s -> toPrimitiveInt(s);

     */
    public static CopyOptions dateConverter(final String pattern, final CharSequence... propertyNames) {
        return new CopyOptions().dateConverter(pattern, propertyNames);
    }

    /**
     * Returns a {@link CopyOptions} with a SQL date converter applied.
     *
     * @param pattern
     *            The date pattern. Must not be {@literal null} or an empty string.
     * @param propertyNames

    }

    /**
     * Converts to {@link Double}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Double}
     */
    public static Double toDouble(final Object o, final String pattern) {
        if (o == null) {
            return null;
        } else if (o instanceof Double) {
            return (Double) o;

    }

    /**
     * Converts to {@link Byte}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Byte}
     */
    public static Byte toByte(final Object o, final String pattern) {
        if (o == null) {
            return null;
        } else if (o instanceof Byte) {
            return (Byte) o;

        // Pattern uses Object (identity) equality, so we have to reach
        // inside to compare individual fields.
        return Objects.equals(pattern.pattern(), that.pattern.pattern())
            && pattern.flags() == that.pattern.flags();
      }
      return false;
    }

    @Override
    public String toString() {
      String patternString =

        } finally {
            System.clearProperty("lasta.env");
        }
    }

    public void test_createPathMatcher_encodeUrl() {
        final Pattern pattern = Pattern.compile("test");
        final Matcher matcher = pattern.matcher("test");
        final BiFunction<String, Matcher, String> pathMatcher = pathMappingHelper.createPathMatcher(matcher, "function:encodeUrl");

        try {
            final String pattern = getPattern(messageCode);
            if (pattern != null) {
                return MessageFormat.format(pattern, args);
            }
            return getNoPatternMessage(args);
        } catch (final Throwable ignore) {
            return getNoPatternMessage(args);
        }
    }

    /**
     * Returns the pattern string corresponding to the message code.
     *

    /** Pattern for extracting charset from meta tags. */
    protected Pattern metaCharsetPattern = Pattern.compile("<meta.*content\\s*=\\s*['\"].*;\\s*charset=([\\w\\d\\-_]*)['\"]\\s*/?>",
            Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);

    /**
     * Pattern for HTML tags.
     */
    protected Pattern htmlTagPattern = Pattern.compile("<[^>]+>");

    /** Map of parser features. */

		<Property name="audit.log.pattern" value="%msg%n" />
		<Property name="searchlog.log.pattern" value="%msg%n" />
	</Properties>

	<Appenders>
		<RollingFile name="AppFile" fileName="${log.file.basedir}/${domain.name}.log"
			filePattern="${log.file.basedir}/${domain.name}${backup.date.suffix}-%i.log.gz">