* - When updating the watches, we watch watchable hierarchies registered for this build or old watched directories from previous builds instead of
 *   directories inside them.
 * - At the end of the build
 *   - stop watching the watchable directories with nothing to watch inside
 *   - remember the currently watched directories as old watched directories for the next build
 *   - remove everything that isn't watched from the virtual file system.

    }

    public static JarCompat open(File jarFile) throws IOException {
        if (JAVA_9_COMPATIBLE) {
            return new MultiReleaseSupportingJar(jarFile);
        }
        // Running on Java 8, fall back to the old ways.
        return new LegacyJar(jarFile);
    }


    private static class LegacyJar extends JarCompat {
        public LegacyJar(File jarFile) throws IOException {
            super(new JarFile(jarFile));

                        return;
                    } catch (IllegalArgumentException ignored) {
                        // Bad file URI, use old logic
                    }
                } catch (URISyntaxException ignored) {
                    // Unparsable, use old logic
                }
                // Fallback if relative or unparsable

    }

    /**
     * Checks if a String is whitespace, empty ("") or null.
     * <p>
     * This function was copied from Apache Commons-Lang to restore TAPI compatibility
     * with Java 6 on old Gradle versions because StringUtils require SQLException which
     * is absent from Java 6.
     */
    public static boolean isBlank(String str) {
        int strLen;

 * limitations under the License.
 */

package org.gradle.util.internal;

import com.google.common.collect.Lists;

import java.util.LinkedList;
import java.util.List;

/**
 * Discards old entries when current count is over the limit.
 *
 * @deprecated Used only by a deprecated public class GFileUtils. Prefer Guava's EvictionQueue in the new code.
 */
@Deprecated
public class LimitedDescription {

     * Here we automatically accept the following cases:
     * - A setter `setX` of an upgraded property is removed
     * - A boolean `isX` of an upgraded property is removed
     * - A new getter `getX` is added, where the old getter is a boolean getter `isX` of an upgraded property
     * - A return type is changed for a getter `getX` of an upgraded property
     *

        }
    }

    private static String errorMessageFor(String factory) {
        return "Unable to create secure " + factory + ", please make sure that your build does not depend on an old XML parser.";
    }

    private XmlFactories() {}

        try {
            int ordinal = dataInput.readByte();
            if (ordinal < TYPES.size()) {
                return TYPES.get(ordinal);
            }
        } catch (EOFException ignore) {
            // old versions don't send a type
        }
        return UNKNOWN;
    }

            // When there's a convention-supporting object, use its `.convention()` method instead
            // This is something we added to support properties migrated in the future from
            // Java bean to Property where old code uses ConventionMapping to set conventions.
            Class<? extends IConventionAware> sourceType = _source.getClass();
            Method getter = JavaPropertyReflectionUtil.findGetterMethod(sourceType, propertyName);

    /**
     * Runs the given {@link Factory} while the specified locks are released and the given new lock is acquired. On completion,
     * the new lock is released and the old locks reacquired.
     * If a lock cannot be immediately (re)acquired, the current worker lease will be released and the method will block until the locks are (re)acquired.
     */