src/share/classes/java/nio/file/FileTreeWalker.java - platform/external/jetbrains/jdk8u_jdk - Git at Google

 /*
  * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package java.nio.file;

 import java.nio.file.attribute.BasicFileAttributeView;
 import java.nio.file.attribute.BasicWithKeyFileAttributeView;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.Collection;
 import java.util.Iterator;
 import sun.nio.fs.BasicFileAttributesHolder;

 /**
  * Walks a file tree, generating a sequence of events corresponding to the files
  * in the tree.
  *
  * <pre>{@code
  *     Path top = ...
  *     Set<FileVisitOption> options = ...
  *     int maxDepth = ...
  *
  *     try (FileTreeWalker walker = new FileTreeWalker(options, maxDepth)) {
  *         FileTreeWalker.Event ev = walker.walk(top);
  *         do {
  *             process(ev);
  *             ev = walker.next();
  *         } while (ev != null);
  *     }
  * }</pre>
  *
  * @see Files#walkFileTree
  */

 class FileTreeWalker implements Closeable {
     private final boolean followLinks;
     private final LinkOption[] linkOptions;
     private final int maxDepth;
     private final ArrayDeque<DirectoryNode> stack = new ArrayDeque<>();
     private boolean closed;

     /**
      * The element on the walking stack corresponding to a directory node.
      */
     private static class DirectoryNode {
         private final Path dir;
         private final Object key;
         private final DirectoryStream<Path> stream;
         private final Iterator<Path> iterator;
         private boolean skipped;

         DirectoryNode(Path dir, Object key, DirectoryStream<Path> stream) {
             this.dir = dir;
             this.key = key;
             this.stream = stream;
             this.iterator = stream.iterator();
         }

         Path directory() {
             return dir;
         }

         Object key() {
             return key;
         }

         DirectoryStream<Path> stream() {
             return stream;
         }

         Iterator<Path> iterator() {
             return iterator;
         }

         void skip() {
             skipped = true;
         }

         boolean skipped() {
             return skipped;
         }
     }

     /**
      * The event types.
      */
     static enum EventType {
         /**
          * Start of a directory
          */
         START_DIRECTORY,
         /**
          * End of a directory
          */
         END_DIRECTORY,
         /**
          * An entry in a directory
          */
         ENTRY;
     }

     /**
      * Events returned by the {@link #walk} and {@link #next} methods.
      */
     static class Event {
         private final EventType type;
         private final Path file;
         private final BasicFileAttributes attrs;
         private final IOException ioe;

         private Event(EventType type, Path file, BasicFileAttributes attrs, IOException ioe) {
             this.type = type;
             this.file = file;
             this.attrs = attrs;
             this.ioe = ioe;
         }

         Event(EventType type, Path file, BasicFileAttributes attrs) {
             this(type, file, attrs, null);
         }

         Event(EventType type, Path file, IOException ioe) {
             this(type, file, null, ioe);
         }

         EventType type() {
             return type;
         }

         Path file() {
             return file;
         }

         BasicFileAttributes attributes() {
             return attrs;
         }

         IOException ioeException() {
             return ioe;
         }
     }

     /**
      * Creates a {@code FileTreeWalker}.
      *
      * @throws  IllegalArgumentException
      *          if {@code maxDepth} is negative
      * @throws  ClassCastException
      *          if (@code options} contains an element that is not a
      *          {@code FileVisitOption}
      * @throws  NullPointerException
      *          if {@code options} is {@ocde null} or the options
      *          array contains a {@code null} element
      */
     FileTreeWalker(Collection<FileVisitOption> options, int maxDepth) {
         boolean fl = false;
         for (FileVisitOption option: options) {
             // will throw NPE if options contains null
             switch (option) {
                 case FOLLOW_LINKS : fl = true; break;
                 default:
                     throw new AssertionError("Should not get here");
             }
         }
         if (maxDepth < 0)
             throw new IllegalArgumentException("'maxDepth' is negative");

         this.followLinks = fl;
         this.linkOptions = (fl) ? new LinkOption[0] :
             new LinkOption[] { LinkOption.NOFOLLOW_LINKS };
         this.maxDepth = maxDepth;
     }

     /**
      * Returns the attributes of the given file, taking into account whether
      * the walk is following sym links is not. The {@code canUseCached}
      * argument determines whether this method can use cached attributes.
      */
     private BasicFileAttributes getAttributes(Path file, boolean canUseCached)
         throws IOException
     {
         // if attributes are cached then use them if possible
         if (canUseCached &&
             (file instanceof BasicFileAttributesHolder) &&
             (System.getSecurityManager() == null))
         {
             BasicFileAttributes cached = ((BasicFileAttributesHolder)file).get();
             if (cached != null && (!followLinks || !cached.isSymbolicLink())) {
                 return cached;
             }
         }

         // attempt to get attributes of file. If fails and we are following
         // links then a link target might not exist so get attributes of link
         BasicFileAttributes attrs;
         try {
             BasicFileAttributeView view = Files.getFileAttributeView(file, BasicWithKeyFileAttributeView.class, linkOptions);
             if (view == null) {
                 view = Files.getFileAttributeView(file, BasicFileAttributeView.class, linkOptions);
             }
             attrs = view.readAttributes();
         } catch (IOException ioe) {
             if (!followLinks)
                 throw ioe;

             // attempt to get attrmptes without following links
             attrs = Files.readAttributes(file,
                                          BasicFileAttributes.class,
                                          LinkOption.NOFOLLOW_LINKS);
         }
         return attrs;
     }

     /**
      * Returns true if walking into the given directory would result in a
      * file system loop/cycle.
      */
     private boolean wouldLoop(Path dir, Object key) {
         // if this directory and ancestor has a file key then we compare
         // them; otherwise we use less efficient isSameFile test.
         for (DirectoryNode ancestor: stack) {
             Object ancestorKey = ancestor.key();
             if (key != null && ancestorKey != null) {
                 if (key.equals(ancestorKey)) {
                     // cycle detected
                     return true;
                 }
             } else {
                 try {
                     if (Files.isSameFile(dir, ancestor.directory())) {
                         // cycle detected
                         return true;
                     }
                 } catch (IOException | SecurityException x) {
                     // ignore
                 }
             }
         }
         return false;
     }

     /**
      * Visits the given file, returning the {@code Event} corresponding to that
      * visit.
      *
      * The {@code ignoreSecurityException} parameter determines whether
      * any SecurityException should be ignored or not. If a SecurityException
      * is thrown, and is ignored, then this method returns {@code null} to
      * mean that there is no event corresponding to a visit to the file.
      *
      * The {@code canUseCached} parameter determines whether cached attributes
      * for the file can be used or not.
      */
     private Event visit(Path entry, boolean ignoreSecurityException, boolean canUseCached) {
         // need the file attributes
         BasicFileAttributes attrs;
         try {
             attrs = getAttributes(entry, canUseCached);
         } catch (IOException ioe) {
             return new Event(EventType.ENTRY, entry, ioe);
         } catch (SecurityException se) {
             if (ignoreSecurityException)
                 return null;
             throw se;
         }

         // at maximum depth or file is not a directory
         int depth = stack.size();
         if (depth >= maxDepth || !attrs.isDirectory()) {
             return new Event(EventType.ENTRY, entry, attrs);
         }

         // check for cycles when following links
         if (followLinks && wouldLoop(entry, attrs.fileKey())) {
             return new Event(EventType.ENTRY, entry,
                              new FileSystemLoopException(entry.toString()));
         }

         // file is a directory, attempt to open it
         DirectoryStream<Path> stream = null;
         try {
             stream = Files.newDirectoryStream(entry);
         } catch (IOException ioe) {
             return new Event(EventType.ENTRY, entry, ioe);
         } catch (SecurityException se) {
             if (ignoreSecurityException)
                 return null;
             throw se;
         }

         // push a directory node to the stack and return an event
         stack.push(new DirectoryNode(entry, attrs.fileKey(), stream));
         return new Event(EventType.START_DIRECTORY, entry, attrs);
     }


     /**
      * Start walking from the given file.
      */
     Event walk(Path file) {
         if (closed)
             throw new IllegalStateException("Closed");

         Event ev = visit(file,
                          false,   // ignoreSecurityException
                          false);  // canUseCached
         assert ev != null;
         return ev;
     }

     /**
      * Returns the next Event or {@code null} if there are no more events or
      * the walker is closed.
      */
     Event next() {
         DirectoryNode top = stack.peek();
         if (top == null)
             return null;      // stack is empty, we are done

         // continue iteration of the directory at the top of the stack
         Event ev;
         do {
             Path entry = null;
             IOException ioe = null;

             // get next entry in the directory
             if (!top.skipped()) {
                 Iterator<Path> iterator = top.iterator();
                 try {
                     if (iterator.hasNext()) {
                         entry = iterator.next();
                     }
                 } catch (DirectoryIteratorException x) {
                     ioe = x.getCause();
                 }
             }

             // no next entry so close and pop directory, creating corresponding event
             if (entry == null) {
                 try {
                     top.stream().close();
                 } catch (IOException e) {
                     if (ioe != null) {
                         ioe = e;
                     } else {
                         ioe.addSuppressed(e);
                     }
                 }
                 stack.pop();
                 return new Event(EventType.END_DIRECTORY, top.directory(), ioe);
             }

             // visit the entry
             ev = visit(entry,
                        true,   // ignoreSecurityException
                        true);  // canUseCached

         } while (ev == null);

         return ev;
     }

     /**
      * Pops the directory node that is the current top of the stack so that
      * there are no more events for the directory (including no END_DIRECTORY)
      * event. This method is a no-op if the stack is empty or the walker is
      * closed.
      */
     void pop() {
         if (!stack.isEmpty()) {
             DirectoryNode node = stack.pop();
             try {
                 node.stream().close();
             } catch (IOException ignore) { }
         }
     }

     /**
      * Skips the remaining entries in the directory at the top of the stack.
      * This method is a no-op if the stack is empty or the walker is closed.
      */
     void skipRemainingSiblings() {
         if (!stack.isEmpty()) {
             stack.peek().skip();
         }
     }

     /**
      * Returns {@code true} if the walker is open.
      */
     boolean isOpen() {
         return !closed;
     }

     /**
      * Closes/pops all directories on the stack.
      */
     @Override
     public void close() {
         if (!closed) {
             while (!stack.isEmpty()) {
                 pop();
             }
             closed = true;
         }
     }
 }
	/*
	* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.nio.file;

	import java.nio.file.attribute.BasicFileAttributeView;
	import java.nio.file.attribute.BasicWithKeyFileAttributeView;
	import java.nio.file.attribute.BasicFileAttributes;
	import java.io.Closeable;
	import java.io.IOException;
	import java.util.ArrayDeque;
	import java.util.Collection;
	import java.util.Iterator;
	import sun.nio.fs.BasicFileAttributesHolder;

	/**
	* Walks a file tree, generating a sequence of events corresponding to the files
	* in the tree.
	*
	* <pre>{@code
	* Path top = ...
	* Set<FileVisitOption> options = ...
	* int maxDepth = ...
	*
	* try (FileTreeWalker walker = new FileTreeWalker(options, maxDepth)) {
	* FileTreeWalker.Event ev = walker.walk(top);
	* do {
	* process(ev);
	* ev = walker.next();
	* } while (ev != null);
	* }
	* }</pre>
	*
	* @see Files#walkFileTree
	*/

	class FileTreeWalker implements Closeable {
	private final boolean followLinks;
	private final LinkOption[] linkOptions;
	private final int maxDepth;
	private final ArrayDeque<DirectoryNode> stack = new ArrayDeque<>();
	private boolean closed;

	/**
	* The element on the walking stack corresponding to a directory node.
	*/
	private static class DirectoryNode {
	private final Path dir;
	private final Object key;
	private final DirectoryStream<Path> stream;
	private final Iterator<Path> iterator;
	private boolean skipped;

	DirectoryNode(Path dir, Object key, DirectoryStream<Path> stream) {
	this.dir = dir;
	this.key = key;
	this.stream = stream;
	this.iterator = stream.iterator();
	}

	Path directory() {
	return dir;
	}

	Object key() {
	return key;
	}

	DirectoryStream<Path> stream() {
	return stream;
	}

	Iterator<Path> iterator() {
	return iterator;
	}

	void skip() {
	skipped = true;
	}

	boolean skipped() {
	return skipped;
	}
	}

	/**
	* The event types.
	*/
	static enum EventType {
	/**
	* Start of a directory
	*/
	START_DIRECTORY,
	/**
	* End of a directory
	*/
	END_DIRECTORY,
	/**
	* An entry in a directory
	*/
	ENTRY;
	}

	/**
	* Events returned by the {@link #walk} and {@link #next} methods.
	*/
	static class Event {
	private final EventType type;
	private final Path file;
	private final BasicFileAttributes attrs;
	private final IOException ioe;

	private Event(EventType type, Path file, BasicFileAttributes attrs, IOException ioe) {
	this.type = type;
	this.file = file;
	this.attrs = attrs;
	this.ioe = ioe;
	}

	Event(EventType type, Path file, BasicFileAttributes attrs) {
	this(type, file, attrs, null);
	}

	Event(EventType type, Path file, IOException ioe) {
	this(type, file, null, ioe);
	}

	EventType type() {
	return type;
	}

	Path file() {
	return file;
	}

	BasicFileAttributes attributes() {
	return attrs;
	}

	IOException ioeException() {
	return ioe;
	}
	}

	/**
	* Creates a {@code FileTreeWalker}.
	*
	* @throws IllegalArgumentException
	* if {@code maxDepth} is negative
	* @throws ClassCastException
	* if (@code options} contains an element that is not a
	* {@code FileVisitOption}
	* @throws NullPointerException
	* if {@code options} is {@ocde null} or the options
	* array contains a {@code null} element
	*/
	FileTreeWalker(Collection<FileVisitOption> options, int maxDepth) {
	boolean fl = false;
	for (FileVisitOption option: options) {
	// will throw NPE if options contains null
	switch (option) {
	case FOLLOW_LINKS : fl = true; break;
	default:
	throw new AssertionError("Should not get here");
	}
	}
	if (maxDepth < 0)
	throw new IllegalArgumentException("'maxDepth' is negative");

	this.followLinks = fl;
	this.linkOptions = (fl) ? new LinkOption[0] :
	new LinkOption[] { LinkOption.NOFOLLOW_LINKS };
	this.maxDepth = maxDepth;
	}

	/**
	* Returns the attributes of the given file, taking into account whether
	* the walk is following sym links is not. The {@code canUseCached}
	* argument determines whether this method can use cached attributes.
	*/
	private BasicFileAttributes getAttributes(Path file, boolean canUseCached)
	throws IOException
	{
	// if attributes are cached then use them if possible
	if (canUseCached &&
	(file instanceof BasicFileAttributesHolder) &&
	(System.getSecurityManager() == null))
	{
	BasicFileAttributes cached = ((BasicFileAttributesHolder)file).get();
	if (cached != null && (!followLinks \|\| !cached.isSymbolicLink())) {
	return cached;
	}
	}

	// attempt to get attributes of file. If fails and we are following
	// links then a link target might not exist so get attributes of link
	BasicFileAttributes attrs;
	try {
	BasicFileAttributeView view = Files.getFileAttributeView(file, BasicWithKeyFileAttributeView.class, linkOptions);
	if (view == null) {
	view = Files.getFileAttributeView(file, BasicFileAttributeView.class, linkOptions);
	}
	attrs = view.readAttributes();
	} catch (IOException ioe) {
	if (!followLinks)
	throw ioe;

	// attempt to get attrmptes without following links
	attrs = Files.readAttributes(file,
	BasicFileAttributes.class,
	LinkOption.NOFOLLOW_LINKS);
	}
	return attrs;
	}

	/**
	* Returns true if walking into the given directory would result in a
	* file system loop/cycle.
	*/
	private boolean wouldLoop(Path dir, Object key) {
	// if this directory and ancestor has a file key then we compare
	// them; otherwise we use less efficient isSameFile test.
	for (DirectoryNode ancestor: stack) {
	Object ancestorKey = ancestor.key();
	if (key != null && ancestorKey != null) {
	if (key.equals(ancestorKey)) {
	// cycle detected
	return true;
	}
	} else {
	try {
	if (Files.isSameFile(dir, ancestor.directory())) {
	// cycle detected
	return true;
	}
	} catch (IOException \| SecurityException x) {
	// ignore
	}
	}
	}
	return false;
	}

	/**
	* Visits the given file, returning the {@code Event} corresponding to that
	* visit.
	*
	* The {@code ignoreSecurityException} parameter determines whether
	* any SecurityException should be ignored or not. If a SecurityException
	* is thrown, and is ignored, then this method returns {@code null} to
	* mean that there is no event corresponding to a visit to the file.
	*
	* The {@code canUseCached} parameter determines whether cached attributes
	* for the file can be used or not.
	*/
	private Event visit(Path entry, boolean ignoreSecurityException, boolean canUseCached) {
	// need the file attributes
	BasicFileAttributes attrs;
	try {
	attrs = getAttributes(entry, canUseCached);
	} catch (IOException ioe) {
	return new Event(EventType.ENTRY, entry, ioe);
	} catch (SecurityException se) {
	if (ignoreSecurityException)
	return null;
	throw se;
	}

	// at maximum depth or file is not a directory
	int depth = stack.size();
	if (depth >= maxDepth \|\| !attrs.isDirectory()) {
	return new Event(EventType.ENTRY, entry, attrs);
	}

	// check for cycles when following links
	if (followLinks && wouldLoop(entry, attrs.fileKey())) {
	return new Event(EventType.ENTRY, entry,
	new FileSystemLoopException(entry.toString()));
	}

	// file is a directory, attempt to open it
	DirectoryStream<Path> stream = null;
	try {
	stream = Files.newDirectoryStream(entry);
	} catch (IOException ioe) {
	return new Event(EventType.ENTRY, entry, ioe);
	} catch (SecurityException se) {
	if (ignoreSecurityException)
	return null;
	throw se;
	}

	// push a directory node to the stack and return an event
	stack.push(new DirectoryNode(entry, attrs.fileKey(), stream));
	return new Event(EventType.START_DIRECTORY, entry, attrs);
	}


	/**
	* Start walking from the given file.
	*/
	Event walk(Path file) {
	if (closed)
	throw new IllegalStateException("Closed");

	Event ev = visit(file,
	false, // ignoreSecurityException
	false); // canUseCached
	assert ev != null;
	return ev;
	}

	/**
	* Returns the next Event or {@code null} if there are no more events or
	* the walker is closed.
	*/
	Event next() {
	DirectoryNode top = stack.peek();
	if (top == null)
	return null; // stack is empty, we are done

	// continue iteration of the directory at the top of the stack
	Event ev;
	do {
	Path entry = null;
	IOException ioe = null;

	// get next entry in the directory
	if (!top.skipped()) {
	Iterator<Path> iterator = top.iterator();
	try {
	if (iterator.hasNext()) {
	entry = iterator.next();
	}
	} catch (DirectoryIteratorException x) {
	ioe = x.getCause();
	}
	}

	// no next entry so close and pop directory, creating corresponding event
	if (entry == null) {
	try {
	top.stream().close();
	} catch (IOException e) {
	if (ioe != null) {
	ioe = e;
	} else {
	ioe.addSuppressed(e);
	}
	}
	stack.pop();
	return new Event(EventType.END_DIRECTORY, top.directory(), ioe);
	}

	// visit the entry
	ev = visit(entry,
	true, // ignoreSecurityException
	true); // canUseCached

	} while (ev == null);

	return ev;
	}

	/**
	* Pops the directory node that is the current top of the stack so that
	* there are no more events for the directory (including no END_DIRECTORY)
	* event. This method is a no-op if the stack is empty or the walker is
	* closed.
	*/
	void pop() {
	if (!stack.isEmpty()) {
	DirectoryNode node = stack.pop();
	try {
	node.stream().close();
	} catch (IOException ignore) { }
	}
	}

	/**
	* Skips the remaining entries in the directory at the top of the stack.
	* This method is a no-op if the stack is empty or the walker is closed.
	*/
	void skipRemainingSiblings() {
	if (!stack.isEmpty()) {
	stack.peek().skip();
	}
	}

	/**
	* Returns {@code true} if the walker is open.
	*/
	boolean isOpen() {
	return !closed;
	}

	/**
	* Closes/pops all directories on the stack.
	*/
	@Override
	public void close() {
	if (!closed) {
	while (!stack.isEmpty()) {
	pop();
	}
	closed = true;
	}
	}
	}