*            The {@link Reader} to read strings from. Must not be {@literal null}.
     */
    public LineIterator(final Reader reader) {
        assertArgumentNotNull("reader", reader);
        this.reader = new BufferedReader(reader);
    }

    /**
     * Constructs an instance.
     *
     * @param reader
     *            The {@link BufferedReader} to read strings from. Must not be {@literal null}.
     */

     * @return t if not <code>null</code>, otherwise defaultValue
     */
    public static <T> T defaultValue(final T t, final T defaultValue) {
        return t == null ? defaultValue : t;
    }

    /**
     * Returns true if the two objects are not equal.
     *
     * @param o1 the first object
     * @param o2 the second object
     * @return true if not equal, false otherwise
     */

    // Not supported due to access checks on JDK 9+:
    // java.lang.reflect.InaccessibleObjectException: Unable to make member of class
    // sun.security.ssl.SSLSocketFactoryImpl accessible:  module java.base does not export
    // sun.security.ssl to unnamed module @xxx
    throw UnsupportedOperationException(
      "clientBuilder.sslSocketFactory(SSLSocketFactory) not supported on JDK 8 (>= 252) or JDK 9+",
    )

     * responsible for creating a copy of the original data and store the copy in the cache.
     *
     * @param request The repository request from which this cache was retrieved, must not be {@code null}.
     * @param key The key to use associate the data with, must not be {@code null}.
     * @param data The data to store in the cache, may be {@code null}.
     */
    void put(RepositoryRequest request, Object key, Object data);

    /**

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<ElevateWordCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<ElevateWordCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<JobLogCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<JobLogCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

 */
public abstract class DocumentBuilderUtil {

    /**
     * Do not instantiate.
     */
    protected DocumentBuilderUtil() {
    }

    /**
     * Parses the XML.
     *
     * @param builder
     *            {@link DocumentBuilder}; must not be {@literal null}.
     * @param is
     *            Input stream; must not be {@literal null}.
     * @return {@link Document}
     */

        assertTrue(filter1.equals(filter1), "Expected " + filter1 + " to equal " + filter1);
        assertEquals(filter1.hashCode(), filter1.hashCode());

        assertFalse(filter1.equals(filter2), "Expected " + filter1 + " to not equal " + filter2);
        assertFalse(filter2.equals(filter1), "Expected " + filter2 + " to not equal " + filter1);
    }

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

type complex128 complex128

// string is the set of all strings of 8-bit bytes, conventionally but not
// necessarily representing UTF-8-encoded text. A string may be empty, but
// not nil. Values of string type are immutable.
type string string

// int is a signed integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, int32.
type int int