*/

package com.google.common.hash;

import com.google.common.base.Supplier;
import com.google.errorprone.annotations.Immutable;

/**
 * Explicitly named subinterface of {@link Supplier} that can be marked {@literal @}{@link
 * Immutable}.
 */
// TODO(cpovirk): Should we just use ChecksumType directly instead of defining this type?
@Immutable

    /**
     * Returns an {@link Iterable} that wraps an {@link Enumeration} for use in a for-each statement.
     *
     * @param <T> the element type
     * @param enumeration the enumeration (must not be {@literal null})
     * @return an {@link Iterable} wrapping the enumeration
     */
    public static <T> Iterable<T> iterable(final Enumeration<T> enumeration) {
        assertArgumentNotNull("enumeration", enumeration);

     */
    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}
     */
    public static Document parse(final DocumentBuilder builder, final InputStream is) {
        assertArgumentNotNull("builder", builder);

    }

    private static final int BYTE_ARRAY_SIZE = 8 * 1024;

    /**
     * Tests if the object can be serialized.
     *
     * @param obj the object to be serialized (must not be {@literal null})
     * @return the deserialized object
     */
    public static Object serialize(final Object obj) {
        assertArgumentNotNull("obj", obj);

        final byte[] binary = fromObjectToBinary(obj);

    }

    /**
     * A method that wraps the exception handling of {@link ZipInputStream#getNextEntry()}.
     *
     * @param zis
     *            {@link ZipInputStream}. Must not be {@literal null}.
     * @return {@link ZipEntry}
     * @see ZipInputStream#getNextEntry()
     */
    public static ZipEntry getNextEntry(final ZipInputStream zis) {
        assertArgumentNotNull("zis", zis);

        try {

     * @return an {@link Iterable} wrapping a {@link ClassLoaderIterator}
     */
    public static Iterable<ClassLoader> iterable(final ClassLoader classLoader) {
        return () -> new ClassLoaderIterator(classLoader);
    }

    /**
     * Constructs an instance.
     *
     * @param classLoader the class loader (must not be {@literal null})
     */

 *    "www.squareup.com".
 *
 *  * **A set of hostnames.** These are in the certificate's subject alternative name (SAN)
 *    extension. A subject alternative name is either a literal hostname (`squareup.com`), a literal
 *    IP address (`74.122.190.80`), or a hostname pattern (`*.api.squareup.com`).
 *
 *  * **A validity interval.** A certificate should not be used before its validity interval starts
 *    or after it ends.

    /**
     * Returns an {@link Iterable} that wraps the array for use in a for-each statement.
     *
     * @param <T> the type of elements
     * @param items the array of elements to iterate (must not be {@literal null})
     * @return an {@link Iterable} wrapping the array
     */
    public static <T> Iterable<T> iterable(final T... items) {
        assertArgumentNotNull("items", items);

 * for injection. It can be used to prevent unintended automatic binding of implemented
 * interfaces or extended classes.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Typed(ServiceImpl.class)
 * public class ServiceImpl implements Service {
 *     // Implementation
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target({FIELD, METHOD, TYPE})
@Retention(RUNTIME)
@Documented

        for (final byte b : bytes) {
            appendHex(sb, b);
        }
        return new String(sb);
    }

    /**
     * Converts an {@literal int} value to a hexadecimal string.
     *
     * @param i
     *            the {@literal int} value
     * @return the hexadecimal string
     */
    public static String toHex(final int i) {
        final StringBuilder buf = new StringBuilder();