tikhomirov@58: /*
tikhomirov@537:  * Copyright (c) 2011-2013 TMate Software Ltd
tikhomirov@74:  *  
tikhomirov@74:  * This program is free software; you can redistribute it and/or modify
tikhomirov@74:  * it under the terms of the GNU General Public License as published by
tikhomirov@74:  * the Free Software Foundation; version 2 of the License.
tikhomirov@74:  *
tikhomirov@74:  * This program is distributed in the hope that it will be useful,
tikhomirov@74:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
tikhomirov@74:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
tikhomirov@74:  * GNU General Public License for more details.
tikhomirov@74:  *
tikhomirov@74:  * For information on how to redistribute this software under
tikhomirov@74:  * the terms of a license other than GNU General Public License
tikhomirov@102:  * contact TMate Software at support@hg4j.com
tikhomirov@58:  */
tikhomirov@74: package org.tmatesoft.hg.repo;
tikhomirov@58: 
tikhomirov@120: import static java.lang.Math.max;
tikhomirov@117: import static java.lang.Math.min;
tikhomirov@218: import static org.tmatesoft.hg.repo.HgRepository.*;
tikhomirov@456: import static org.tmatesoft.hg.util.LogFacility.Severity.*;
tikhomirov@58: 
tikhomirov@58: import java.io.File;
tikhomirov@58: import java.io.IOException;
tikhomirov@117: import java.nio.ByteBuffer;
tikhomirov@287: import java.nio.channels.ReadableByteChannel;
tikhomirov@229: import java.util.ArrayList;
tikhomirov@58: import java.util.Collections;
tikhomirov@226: import java.util.NoSuchElementException;
tikhomirov@58: import java.util.Set;
tikhomirov@58: import java.util.TreeSet;
tikhomirov@58: 
tikhomirov@74: import org.tmatesoft.hg.core.Nodeid;
tikhomirov@425: import org.tmatesoft.hg.core.SessionContext;
tikhomirov@157: import org.tmatesoft.hg.internal.ByteArrayChannel;
tikhomirov@628: import org.tmatesoft.hg.internal.FileUtils;
tikhomirov@117: import org.tmatesoft.hg.internal.FilterByteChannel;
tikhomirov@413: import org.tmatesoft.hg.internal.Internals;
tikhomirov@248: import org.tmatesoft.hg.internal.ManifestRevision;
tikhomirov@431: import org.tmatesoft.hg.internal.PathPool;
tikhomirov@229: import org.tmatesoft.hg.internal.PathScope;
tikhomirov@355: import org.tmatesoft.hg.internal.Preview;
tikhomirov@356: import org.tmatesoft.hg.util.Adaptable;
tikhomirov@117: import org.tmatesoft.hg.util.ByteChannel;
tikhomirov@423: import org.tmatesoft.hg.util.CancelSupport;
tikhomirov@157: import org.tmatesoft.hg.util.CancelledException;
tikhomirov@431: import org.tmatesoft.hg.util.Convertor;
tikhomirov@287: import org.tmatesoft.hg.util.FileInfo;
tikhomirov@141: import org.tmatesoft.hg.util.FileIterator;
tikhomirov@226: import org.tmatesoft.hg.util.FileWalker;
tikhomirov@133: import org.tmatesoft.hg.util.Path;
tikhomirov@93: import org.tmatesoft.hg.util.PathRewrite;
tikhomirov@287: import org.tmatesoft.hg.util.RegularFileInfo;
tikhomirov@58: 
tikhomirov@58: /**
tikhomirov@58:  *
tikhomirov@74:  * @author Artem Tikhomirov
tikhomirov@74:  * @author TMate Software Ltd.
tikhomirov@58:  */
tikhomirov@94: public class HgWorkingCopyStatusCollector {
tikhomirov@58: 
tikhomirov@58: 	private final HgRepository repo;
tikhomirov@141: 	private final FileIterator repoWalker;
tikhomirov@59: 	private HgDirstate dirstate;
tikhomirov@94: 	private HgStatusCollector baseRevisionCollector;
tikhomirov@431: 	private Convertor<Path> pathPool;
tikhomirov@282: 	private ManifestRevision dirstateParentManifest;
tikhomirov@58: 
tikhomirov@362: 	/**
tikhomirov@362: 	 * Collector that iterates over complete working copy
tikhomirov@362: 	 */
tikhomirov@94: 	public HgWorkingCopyStatusCollector(HgRepository hgRepo) {
tikhomirov@229: 		this(hgRepo, new HgInternals(hgRepo).createWorkingDirWalker(null));
tikhomirov@74: 	}
tikhomirov@74: 
tikhomirov@362: 	/**
tikhomirov@362: 	 * Collector may analyze and report status for any arbitrary sub-tree of the working copy.
tikhomirov@362: 	 * File iterator shall return names of the files relative to the repository root.
tikhomirov@362: 	 * 
tikhomirov@362: 	 * @param hgRepo status target repository
tikhomirov@362: 	 * @param workingCopyWalker iterator over files in the working copy
tikhomirov@362: 	 */
tikhomirov@362: 	public HgWorkingCopyStatusCollector(HgRepository hgRepo, FileIterator workingCopyWalker) {
tikhomirov@218: 		repo = hgRepo;
tikhomirov@362: 		repoWalker = workingCopyWalker;
tikhomirov@58: 	}
tikhomirov@59: 	
tikhomirov@59: 	/**
tikhomirov@59: 	 * Optionally, supply a collector instance that may cache (or have already cached) base revision
tikhomirov@59: 	 * @param sc may be null
tikhomirov@59: 	 */
tikhomirov@94: 	public void setBaseRevisionCollector(HgStatusCollector sc) {
tikhomirov@59: 		baseRevisionCollector = sc;
tikhomirov@59: 	}
tikhomirov@93: 
tikhomirov@431: 	/*package-local*/ Convertor<Path> getPathPool() {
tikhomirov@93: 		if (pathPool == null) {
tikhomirov@93: 			if (baseRevisionCollector == null) {
tikhomirov@93: 				pathPool = new PathPool(new PathRewrite.Empty());
tikhomirov@93: 			} else {
tikhomirov@93: 				return baseRevisionCollector.getPathPool();
tikhomirov@93: 			}
tikhomirov@93: 		}
tikhomirov@93: 		return pathPool;
tikhomirov@93: 	}
tikhomirov@93: 
tikhomirov@431: 	public void setPathPool(Convertor<Path> pathConvertor) {
tikhomirov@431: 		pathPool = pathConvertor;
tikhomirov@93: 	}
tikhomirov@93: 
tikhomirov@290: 	/**
tikhomirov@290: 	 * Access to directory state information this collector uses.
tikhomirov@290: 	 * @return directory state holder, never <code>null</code> 
tikhomirov@290: 	 */
tikhomirov@348: 	public HgDirstate getDirstate() throws HgInvalidControlFileException {
tikhomirov@59: 		if (dirstate == null) {
tikhomirov@431: 			Convertor<Path> pp = getPathPool();
tikhomirov@431: 			Path.Source ps;
tikhomirov@431: 			if (pp instanceof Path.Source) {
tikhomirov@431: 				ps = (Path.Source) pp;
tikhomirov@431: 			} else {
tikhomirov@431: 				ps = new Path.SimpleSource(new PathRewrite.Empty(), pp);
tikhomirov@431: 			}
tikhomirov@431: 			dirstate = repo.loadDirstate(ps);
tikhomirov@59: 		}
tikhomirov@59: 		return dirstate;
tikhomirov@59: 	}
tikhomirov@275: 	
tikhomirov@348: 	private HgDirstate getDirstateImpl() {
tikhomirov@348: 		return dirstate;
tikhomirov@348: 	}
tikhomirov@348: 	
tikhomirov@628: 	private ManifestRevision getManifest(int changelogLocalRev) throws HgRuntimeException {
tikhomirov@284: 		assert changelogLocalRev >= 0;
tikhomirov@282: 		ManifestRevision mr;
tikhomirov@282: 		if (baseRevisionCollector != null) {
tikhomirov@282: 			mr = baseRevisionCollector.raw(changelogLocalRev);
tikhomirov@282: 		} else {
tikhomirov@282: 			mr = new ManifestRevision(null, null);
tikhomirov@282: 			repo.getManifest().walk(changelogLocalRev, changelogLocalRev, mr);
tikhomirov@282: 		}
tikhomirov@282: 		return mr;
tikhomirov@282: 	}
tikhomirov@354: 
tikhomirov@628: 	private void initDirstateParentManifest() throws HgRuntimeException {
tikhomirov@354: 		Nodeid dirstateParent = getDirstateImpl().parents().first();
tikhomirov@354: 		if (dirstateParent.isNull()) {
tikhomirov@405: 			dirstateParentManifest = baseRevisionCollector != null ? baseRevisionCollector.raw(NO_REVISION) : HgStatusCollector.createEmptyManifestRevision();
tikhomirov@354: 		} else {
tikhomirov@367: 			int changeloRevIndex = repo.getChangelog().getRevisionIndex(dirstateParent);
tikhomirov@367: 			dirstateParentManifest = getManifest(changeloRevIndex);
tikhomirov@354: 		}
tikhomirov@354: 	}
tikhomirov@354: 
tikhomirov@354: 	// WC not necessarily points to TIP, but may be result of update to any previous revision.
tikhomirov@354: 	// In such case, we need to compare local files not to their TIP content, but to specific version at the time of selected revision
tikhomirov@282: 	private ManifestRevision getDirstateParentManifest() {
tikhomirov@282: 		return dirstateParentManifest;
tikhomirov@282: 	}
tikhomirov@282: 	
tikhomirov@423: 	/**
tikhomirov@429: 	 * Walk working copy, analyze status for each file found and missing.
tikhomirov@429: 	 * May be invoked few times.
tikhomirov@423: 	 * 
tikhomirov@506: 	 * <p>There's no dedicated constant for working copy parent, at least now. 
tikhomirov@429: 	 * Use {@link HgRepository#WORKING_COPY} to indicate comparison 
tikhomirov@429: 	 * shall be run against working copy parent. Although a bit confusing, single case doesn't 
tikhomirov@429: 	 * justify a dedicated constant.
tikhomirov@429: 	 * 
tikhomirov@429: 	 * @param baseRevision revision index to check against, or {@link HgRepository#WORKING_COPY}. Note, {@link HgRepository#TIP} is not supported.
tikhomirov@429: 	 * @param inspector callback to receive status information
tikhomirov@423: 	 * @throws IOException to propagate IO errors from {@link FileIterator}
tikhomirov@423: 	 * @throws CancelledException if operation execution was cancelled
tikhomirov@423: 	 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em>
tikhomirov@423: 	 */
tikhomirov@423: 	public void walk(int baseRevision, HgStatusInspector inspector) throws IOException, CancelledException, HgRuntimeException {
tikhomirov@367: 		if (HgInternals.wrongRevisionIndex(baseRevision) || baseRevision == BAD_REVISION) {
tikhomirov@425: 			throw new HgInvalidRevisionException(baseRevision);
tikhomirov@218: 		}
tikhomirov@362: 		if (getDirstateImpl() == null) {
tikhomirov@362: 				getDirstate();
tikhomirov@362: 		}
tikhomirov@362: 		if (getDirstateParentManifest() == null) {
tikhomirov@362: 			initDirstateParentManifest();
tikhomirov@348: 		}
tikhomirov@429: 		// XXX NOTE, use of TIP for working copy parent is questionable, at least. Instead, TIP shall mean latest cset or not allowed at all
tikhomirov@282: 		ManifestRevision collect = null; // non null indicates we compare against base revision
tikhomirov@285: 		Set<Path> baseRevFiles = Collections.emptySet(); // files from base revision not affected by status calculation 
tikhomirov@282: 		if (baseRevision != TIP && baseRevision != WORKING_COPY) {
tikhomirov@282: 			collect = getManifest(baseRevision);
tikhomirov@285: 			baseRevFiles = new TreeSet<Path>(collect.files());
tikhomirov@58: 		}
tikhomirov@94: 		if (inspector instanceof HgStatusCollector.Record) {
tikhomirov@94: 			HgStatusCollector sc = baseRevisionCollector == null ? new HgStatusCollector(repo) : baseRevisionCollector;
tikhomirov@282: 			// nodeidAfterChange(dirstate's parent) doesn't make too much sense,
tikhomirov@282: 			// because the change might be actually in working copy. Nevertheless, 
tikhomirov@282: 			// as long as no nodeids can be provided for WC, seems reasonable to report
tikhomirov@282: 			// latest known nodeid change (although at the moment this is not used and
tikhomirov@282: 			// is done mostly not to leave stale initialization in the Record)
tikhomirov@537: 			int rev1,rev2 = getDirstateParentManifest().changesetRevisionIndex();
tikhomirov@282: 			if (baseRevision == TIP || baseRevision == WORKING_COPY) {
tikhomirov@282: 				rev1 = rev2 - 1; // just use revision prior to dirstate's parent
tikhomirov@282: 			} else {
tikhomirov@282: 				rev1 = baseRevision;
tikhomirov@282: 			}
tikhomirov@282: 			((HgStatusCollector.Record) inspector).init(rev1, rev2, sc);
tikhomirov@68: 		}
tikhomirov@423: 		final CancelSupport cs = CancelSupport.Factory.get(inspector);
tikhomirov@282: 		final HgIgnore hgIgnore = repo.getIgnore();
tikhomirov@58: 		repoWalker.reset();
tikhomirov@293: 		TreeSet<Path> processed = new TreeSet<Path>(); // names of files we handled as they known to Dirstate (not FileIterator)
tikhomirov@348: 		final HgDirstate ds = getDirstateImpl();
tikhomirov@293: 		TreeSet<Path> knownEntries = ds.all(); // here just to get dirstate initialized
tikhomirov@58: 		while (repoWalker.hasNext()) {
tikhomirov@423: 			cs.checkCancelled();
tikhomirov@58: 			repoWalker.next();
tikhomirov@431: 			final Path fname = getPathPool().mangle(repoWalker.name());
tikhomirov@287: 			FileInfo f = repoWalker.file();
tikhomirov@293: 			Path knownInDirstate;
tikhomirov@226: 			if (!f.exists()) {
tikhomirov@226: 				// file coming from iterator doesn't exist.
tikhomirov@293: 				if ((knownInDirstate = ds.known(fname)) != null) {
tikhomirov@293: 					// found in dirstate
tikhomirov@293: 					processed.add(knownInDirstate);
tikhomirov@294: 					if (ds.checkRemoved(knownInDirstate) == null) {
tikhomirov@294: 						inspector.missing(knownInDirstate);
tikhomirov@226: 					} else {
tikhomirov@294: 						inspector.removed(knownInDirstate);
tikhomirov@226: 					}
tikhomirov@226: 					// do not report it as removed later
tikhomirov@226: 					if (collect != null) {
tikhomirov@294: 						baseRevFiles.remove(knownInDirstate);
tikhomirov@226: 					}
tikhomirov@226: 				} else {
tikhomirov@226: 					// chances are it was known in baseRevision. We may rely
tikhomirov@226: 					// that later iteration over baseRevFiles leftovers would yield correct Removed,
tikhomirov@226: 					// but it doesn't hurt to be explicit (provided we know fname *is* inScope of the FileIterator
tikhomirov@285: 					if (collect != null && baseRevFiles.remove(fname)) {
tikhomirov@226: 						inspector.removed(fname);
tikhomirov@226: 					} else {
tikhomirov@226: 						// not sure I shall report such files (i.e. arbitrary name coming from FileIterator)
tikhomirov@226: 						// as unknown. Command-line HG aborts "system can't find the file specified"
tikhomirov@226: 						// in similar case (against wc), or just gives nothing if --change <rev> is specified.
tikhomirov@226: 						// however, as it's unlikely to get unexisting files from FileIterator, and
tikhomirov@226: 						// its better to see erroneous file status rather than not to see any (which is too easy
tikhomirov@226: 						// to overlook), I think unknown() is reasonable approach here
tikhomirov@226: 						inspector.unknown(fname);
tikhomirov@226: 					}
tikhomirov@226: 				}
tikhomirov@226: 				continue;
tikhomirov@226: 			}
tikhomirov@293: 			if ((knownInDirstate = ds.known(fname)) != null) {
tikhomirov@226: 				// tracked file.
tikhomirov@58: 				// modified, added, removed, clean
tikhomirov@293: 				processed.add(knownInDirstate);
tikhomirov@58: 				if (collect != null) { // need to check against base revision, not FS file
tikhomirov@294: 					checkLocalStatusAgainstBaseRevision(baseRevFiles, collect, baseRevision, knownInDirstate, f, inspector);
tikhomirov@58: 				} else {
tikhomirov@294: 					checkLocalStatusAgainstFile(knownInDirstate, f, inspector);
tikhomirov@58: 				}
tikhomirov@58: 			} else {
tikhomirov@226: 				if (hgIgnore.isIgnored(fname)) { // hgignore shall be consulted only for non-tracked files
tikhomirov@226: 					inspector.ignored(fname);
tikhomirov@226: 				} else {
tikhomirov@226: 					inspector.unknown(fname);
tikhomirov@226: 				}
tikhomirov@226: 				// the file is not tracked. Even if it's known at baseRevision, we don't need to remove it
tikhomirov@226: 				// from baseRevFiles, it might need to be reported as removed as well (cmdline client does
tikhomirov@226: 				// yield two statuses for the same file)
tikhomirov@58: 			}
tikhomirov@58: 		}
tikhomirov@58: 		if (collect != null) {
tikhomirov@473: 			// perhaps, this code shall go after processing leftovers of knownEntries, below
tikhomirov@473: 			// as it's sort of last resort - what to do with otherwise unprocessed base revision files
tikhomirov@285: 			for (Path fromBase : baseRevFiles) {
tikhomirov@226: 				if (repoWalker.inScope(fromBase)) {
tikhomirov@226: 					inspector.removed(fromBase);
tikhomirov@473: 					processed.add(fromBase);
tikhomirov@423: 					cs.checkCancelled();
tikhomirov@226: 				}
tikhomirov@58: 			}
tikhomirov@58: 		}
tikhomirov@293: 		knownEntries.removeAll(processed);
tikhomirov@284: 		for (Path m : knownEntries) {
tikhomirov@284: 			if (!repoWalker.inScope(m)) {
tikhomirov@226: 				// do not report as missing/removed those FileIterator doesn't care about.
tikhomirov@226: 				continue;
tikhomirov@226: 			}
tikhomirov@423: 			cs.checkCancelled();
tikhomirov@74: 			// missing known file from a working dir  
tikhomirov@293: 			if (ds.checkRemoved(m) == null) {
tikhomirov@74: 				// not removed from the repository = 'deleted'  
tikhomirov@284: 				inspector.missing(m);
tikhomirov@74: 			} else {
tikhomirov@74: 				// removed from the repo
tikhomirov@76: 				// if we check against non-tip revision, do not report files that were added past that revision and now removed.
tikhomirov@285: 				if (collect == null || baseRevFiles.contains(m)) {
tikhomirov@284: 					inspector.removed(m);
tikhomirov@76: 				}
tikhomirov@58: 			}
tikhomirov@58: 		}
tikhomirov@58: 	}
tikhomirov@58: 
tikhomirov@423: 	/**
tikhomirov@429: 	 * A {@link #walk(int, HgStatusInspector)} that records all the status information in the {@link HgStatusCollector.Record} object.
tikhomirov@423: 	 * 
tikhomirov@429: 	 * @see #walk(int, HgStatusInspector)
tikhomirov@429: 	 * @param baseRevision revision index to check against, or {@link HgRepository#WORKING_COPY}. Note, {@link HgRepository#TIP} is not supported.
tikhomirov@423: 	 * @return information object that describes change between the revisions
tikhomirov@423: 	 * @throws IOException to propagate IO errors from {@link FileIterator}
tikhomirov@423: 	 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em>
tikhomirov@423: 	 */
tikhomirov@423: 	public HgStatusCollector.Record status(int baseRevision) throws IOException, HgRuntimeException {
tikhomirov@94: 		HgStatusCollector.Record rv = new HgStatusCollector.Record();
tikhomirov@423: 		try {
tikhomirov@423: 			walk(baseRevision, rv);
tikhomirov@423: 		} catch (CancelledException ex) {
tikhomirov@423: 			// can't happen as long our Record class doesn't implement CancelSupport
tikhomirov@423: 			HgInvalidStateException t = new HgInvalidStateException("Internal error");
tikhomirov@423: 			t.initCause(ex);
tikhomirov@423: 			throw t;
tikhomirov@423: 		}
tikhomirov@58: 		return rv;
tikhomirov@58: 	}
tikhomirov@506: 	
tikhomirov@506: 	/**
tikhomirov@506: 	 * Compares file state from working directory against parent recorded in dirstate. 
tikhomirov@506: 	 * Might be handy for merged files, always reported as 'modified' or files deemed modified
tikhomirov@506: 	 * based on their flags change.
tikhomirov@506: 	 * 
tikhomirov@506: 	 * @param fname repository-relative path to the file in question
tikhomirov@506: 	 * @param fileInfo file content mediator 
tikhomirov@506: 	 * @return <code>true</code> when content in working dir differs from that of manifest-recorded revision 
tikhomirov@506: 	 */
tikhomirov@506: 	public boolean hasTangibleChanges(Path fname, FileInfo fileInfo) throws HgRuntimeException {
tikhomirov@506: 		// see #checkLocalStatusAgainstFile() below for the origin of changed file check
tikhomirov@506: 		HgDataFile df = repo.getFileNode(fname);
tikhomirov@506: 		if (!df.exists()) {
tikhomirov@506: 			throw new HgInvalidFileException("File not found", null).setFileName(fname);
tikhomirov@506: 		}
tikhomirov@506: 		Nodeid rev = getDirstateParentManifest().nodeid(fname);
tikhomirov@506: 		return rev == null || !areTheSame(fileInfo, df, rev);
tikhomirov@506: 	}
tikhomirov@58: 
tikhomirov@58: 	//********************************************
tikhomirov@58: 
tikhomirov@58: 	
tikhomirov@287: 	private void checkLocalStatusAgainstFile(Path fname, FileInfo f, HgStatusInspector inspector) {
tikhomirov@58: 		HgDirstate.Record r;
tikhomirov@348: 		if ((r = getDirstateImpl().checkNormal(fname)) != null) {
tikhomirov@58: 			// either clean or modified
tikhomirov@290: 			final boolean timestampEqual = f.lastModified() == r.modificationTime(), sizeEqual = r.size() == f.length();
tikhomirov@280: 			if (timestampEqual && sizeEqual) {
tikhomirov@413: 				// if flags change (chmod -x), timestamp does not change
tikhomirov@413: 				if (checkFlagsEqual(f, r.mode())) {
tikhomirov@413: 					inspector.clean(fname);
tikhomirov@413: 				} else {
tikhomirov@413: 					inspector.modified(fname); // flags are not the same
tikhomirov@413: 				}
tikhomirov@290: 			} else if (!sizeEqual && r.size() >= 0) {
tikhomirov@280: 				inspector.modified(fname);
tikhomirov@496: 			} else if (r.size() == -2) {
tikhomirov@496: 				// DirState wiki calls this np2 metastate: 
tikhomirov@496: 				// 'np2': merged from other parent (status == 'n', size == -2) 
tikhomirov@496: 				inspector.modified(fname);
tikhomirov@58: 			} else {
tikhomirov@413: 				// size is the same or unknown, and, perhaps, different timestamp
tikhomirov@413: 				// check actual content to avoid false modified files
tikhomirov@397: 				try {
tikhomirov@413: 					if (!checkFlagsEqual(f, r.mode())) {
tikhomirov@413: 						// flags modified, no need to do expensive content check
tikhomirov@413: 						inspector.modified(fname);
tikhomirov@397: 					} else {
tikhomirov@413: 						HgDataFile df = repo.getFileNode(fname);
tikhomirov@413: 						if (!df.exists()) {
tikhomirov@608: 							Internals implRepo = repo.getImplHelper();
tikhomirov@493: 							String msg = String.format("File %s known as normal in dirstate (%d, %d), doesn't exist at %s", fname, r.modificationTime(), r.size(), implRepo.getStoragePath(df));
tikhomirov@413: 							throw new HgInvalidFileException(msg, null).setFileName(fname);
tikhomirov@413: 						}
tikhomirov@413: 						Nodeid rev = getDirstateParentManifest().nodeid(fname);
tikhomirov@413: 						// rev might be null here if fname comes to dirstate as a result of a merge operation
tikhomirov@413: 						// where one of the parents (first parent) had no fname file, but second parent had.
tikhomirov@413: 						// E.g. fork revision 3, revision 4 gets .hgtags, few modifications and merge(3,12)
tikhomirov@413: 						// see Issue 14 for details
tikhomirov@413: 						if (rev == null || !areTheSame(f, df, rev)) {
tikhomirov@413: 							inspector.modified(df.getPath());
tikhomirov@413: 						} else {
tikhomirov@413: 							inspector.clean(df.getPath());
tikhomirov@413: 						}
tikhomirov@397: 					}
tikhomirov@425: 				} catch (HgRuntimeException ex) {
tikhomirov@490: 					repo.getSessionContext().getLog().dump(getClass(), Warn, ex, null);
tikhomirov@397: 					inspector.invalid(fname, ex);
tikhomirov@120: 				}
tikhomirov@58: 			}
tikhomirov@348: 		} else if ((r = getDirstateImpl().checkAdded(fname)) != null) {
tikhomirov@290: 			if (r.copySource() == null) {
tikhomirov@280: 				inspector.added(fname);
tikhomirov@58: 			} else {
tikhomirov@290: 				inspector.copied(r.copySource(), fname);
tikhomirov@58: 			}
tikhomirov@348: 		} else if ((r = getDirstateImpl().checkRemoved(fname)) != null) {
tikhomirov@280: 			inspector.removed(fname);
tikhomirov@348: 		} else if ((r = getDirstateImpl().checkMerged(fname)) != null) {
tikhomirov@280: 			inspector.modified(fname);
tikhomirov@58: 		}
tikhomirov@58: 	}
tikhomirov@58: 	
tikhomirov@58: 	// XXX refactor checkLocalStatus methods in more OO way
tikhomirov@628: 	private void checkLocalStatusAgainstBaseRevision(Set<Path> baseRevNames, ManifestRevision collect, int baseRevision, Path fname, FileInfo f, HgStatusInspector inspector) throws HgRuntimeException {
tikhomirov@58: 		// fname is in the dirstate, either Normal, Added, Removed or Merged
tikhomirov@285: 		Nodeid nid1 = collect.nodeid(fname);
tikhomirov@285: 		HgManifest.Flags flags = collect.flags(fname);
tikhomirov@58: 		HgDirstate.Record r;
tikhomirov@471: 		final HgDirstate ds = getDirstateImpl();
tikhomirov@58: 		if (nid1 == null) {
tikhomirov@471: 			// not known at the time of baseRevision:
tikhomirov@471: 			// normal, added, merged: either added or copied since base revision.
tikhomirov@471: 			// removed: nothing to report, 
tikhomirov@471: 			if (ds.checkNormal(fname) != null || ds.checkMerged(fname) != null) {
tikhomirov@157: 				try {
tikhomirov@689: 					// FIXME refactor, done numerous time e.g. in TestStatus#testStatusCommand with base = 3
tikhomirov@689: 					ArrayList<Nodeid> parents = new ArrayList<Nodeid>(2);
tikhomirov@689: 					parents.add(ds.parents().first());
tikhomirov@689: 					parents.add(ds.parents().second());
tikhomirov@689: 					parents.remove(Nodeid.NULL);
tikhomirov@689: 					// try either parent if file came through one of them, or both
tikhomirov@689: 					for (Nodeid parent : parents) {
tikhomirov@689: 						int csetIndex = repo.getChangelog().getRevisionIndex(parent);
tikhomirov@689: 						Nodeid fileRev = repo.getManifest().getFileRevision(csetIndex, fname);
tikhomirov@689: 						if (fileRev == null) {
tikhomirov@689: 							continue;
tikhomirov@689: 						}
tikhomirov@689: 						// see if file revision known in this parent got copied from one of baseRevNames
tikhomirov@690: 						Path origin = HgStatusCollector.getOriginIfCopy(repo, fname, fileRev, collect.files(), baseRevision);
tikhomirov@689: 						if (origin != null) {
tikhomirov@689: 							inspector.copied(getPathPool().mangle(origin), fname);
tikhomirov@689: 							return;
tikhomirov@689: 						}
tikhomirov@157: 					}
tikhomirov@471: 					// fall-through, report as added
tikhomirov@425: 				} catch (HgInvalidFileException ex) {
tikhomirov@360: 					// report failure and continue status collection
tikhomirov@360: 					inspector.invalid(fname, ex);
tikhomirov@90: 				}
tikhomirov@471: 			} else if ((r = ds.checkAdded(fname)) != null) {
tikhomirov@290: 				if (r.copySource() != null && baseRevNames.contains(r.copySource())) {
tikhomirov@473: 					// shall not remove rename source from baseRevNames, as the source
tikhomirov@473: 					// likely needs to be reported as Removed as well
tikhomirov@290: 					inspector.copied(r.copySource(), fname);
tikhomirov@58: 					return;
tikhomirov@58: 				}
tikhomirov@58: 				// fall-through, report as added
tikhomirov@471: 			} else if (ds.checkRemoved(fname) != null) {
tikhomirov@58: 				// removed: removed file was not known at the time of baseRevision, and we should not report it as removed
tikhomirov@58: 				return;
tikhomirov@58: 			}
tikhomirov@226: 			inspector.added(fname);
tikhomirov@58: 		} else {
tikhomirov@58: 			// was known; check whether clean or modified
tikhomirov@285: 			Nodeid nidFromDirstate = getDirstateParentManifest().nodeid(fname);
tikhomirov@471: 			if ((r = ds.checkNormal(fname)) != null && nid1.equals(nidFromDirstate)) {
tikhomirov@282: 				// regular file, was the same up to WC initialization. Check if was modified since, and, if not, report right away
tikhomirov@282: 				// same code as in #checkLocalStatusAgainstFile
tikhomirov@290: 				final boolean timestampEqual = f.lastModified() == r.modificationTime(), sizeEqual = r.size() == f.length();
tikhomirov@282: 				boolean handled = false;
tikhomirov@280: 				if (timestampEqual && sizeEqual) {
tikhomirov@280: 					inspector.clean(fname);
tikhomirov@282: 					handled = true;
tikhomirov@290: 				} else if (!sizeEqual && r.size() >= 0) {
tikhomirov@280: 					inspector.modified(fname);
tikhomirov@282: 					handled = true;
tikhomirov@413: 				} else if (!checkFlagsEqual(f, flags)) {
tikhomirov@282: 					// seems like flags have changed, no reason to check content further
tikhomirov@282: 					inspector.modified(fname);
tikhomirov@282: 					handled = true;
tikhomirov@282: 				}
tikhomirov@282: 				if (handled) {
tikhomirov@285: 					baseRevNames.remove(fname); // consumed, processed, handled.
tikhomirov@280: 					return;
tikhomirov@280: 				}
tikhomirov@282: 				// otherwise, shall check actual content (size not the same, or unknown (-1 or -2), or timestamp is different,
tikhomirov@282: 				// or nodeid in dirstate is different, but local change might have brought it back to baseRevision state)
tikhomirov@280: 				// FALL THROUGH
tikhomirov@280: 			}
tikhomirov@471: 			if (r != null || (r = ds.checkMerged(fname)) != null || (r = ds.checkAdded(fname)) != null) {
tikhomirov@397: 				try {
tikhomirov@397: 					// check actual content to see actual changes
tikhomirov@397: 					// when added - seems to be the case of a file added once again, hence need to check if content is different
tikhomirov@397: 					// either clean or modified
tikhomirov@397: 					HgDataFile fileNode = repo.getFileNode(fname);
tikhomirov@397: 					if (areTheSame(f, fileNode, nid1)) {
tikhomirov@397: 						inspector.clean(fname);
tikhomirov@397: 					} else {
tikhomirov@397: 						inspector.modified(fname);
tikhomirov@397: 					}
tikhomirov@425: 				} catch (HgRuntimeException ex) {
tikhomirov@490: 					repo.getSessionContext().getLog().dump(getClass(), Warn, ex, null);
tikhomirov@397: 					inspector.invalid(fname, ex);
tikhomirov@58: 				}
tikhomirov@285: 				baseRevNames.remove(fname); // consumed, processed, handled.
tikhomirov@348: 			} else if (getDirstateImpl().checkRemoved(fname) != null) {
tikhomirov@226: 				// was known, and now marked as removed, report it right away, do not rely on baseRevNames processing later
tikhomirov@226: 				inspector.removed(fname);
tikhomirov@285: 				baseRevNames.remove(fname); // consumed, processed, handled.
tikhomirov@58: 			}
tikhomirov@226: 			// only those left in baseRevNames after processing are reported as removed 
tikhomirov@58: 		}
tikhomirov@58: 
tikhomirov@608: 		// TODO [post-1.1] think over if content comparison may be done more effectively by e.g. calculating nodeid for a local file and comparing it with nodeid from manifest
tikhomirov@58: 		// we don't need to tell exact difference, hash should be enough to detect difference, and it doesn't involve reading historical file content, and it's relatively 
tikhomirov@58: 		// cheap to calc hash on a file (no need to keep it completely in memory). OTOH, if I'm right that the next approach is used for nodeids: 
tikhomirov@58: 		// changeset nodeid + hash(actual content) => entry (Nodeid) in the next Manifest
tikhomirov@58: 		// then it's sufficient to check parents from dirstate, and if they do not match parents from file's baseRevision (non matching parents means different nodeids).
tikhomirov@58: 		// The question is whether original Hg treats this case (same content, different parents and hence nodeids) as 'modified' or 'clean'
tikhomirov@58: 	}
tikhomirov@58: 
tikhomirov@628: 	private boolean areTheSame(FileInfo f, HgDataFile dataFile, Nodeid revision) throws HgRuntimeException {
tikhomirov@157: 		// XXX consider adding HgDataDile.compare(File/byte[]/whatever) operation to optimize comparison
tikhomirov@157: 		ByteArrayChannel bac = new ByteArrayChannel();
tikhomirov@157: 		try {
tikhomirov@367: 			int fileRevisionIndex = dataFile.getRevisionIndex(revision);
tikhomirov@157: 			// need content with metadata striped off - although theoretically chances are metadata may be different,
tikhomirov@157: 			// WC doesn't have it anyway 
tikhomirov@367: 			dataFile.content(fileRevisionIndex, bac);
tikhomirov@157: 		} catch (CancelledException ex) {
tikhomirov@157: 			// silently ignore - can't happen, ByteArrayChannel is not cancellable
tikhomirov@157: 		}
tikhomirov@397: 		return areTheSame(f, bac.toArray(), dataFile.getPath());
tikhomirov@157: 	}
tikhomirov@157: 	
tikhomirov@423: 	private boolean areTheSame(FileInfo f, final byte[] data, Path p) throws HgInvalidFileException {
tikhomirov@287: 		ReadableByteChannel is = null;
tikhomirov@295: 		class Check implements ByteChannel {
tikhomirov@490: 			final boolean debug = repo.getSessionContext().getLog().isDebug(); 
tikhomirov@295: 			boolean sameSoFar = true;
tikhomirov@295: 			int x = 0;
tikhomirov@219: 
tikhomirov@295: 			public int write(ByteBuffer buffer) {
tikhomirov@295: 				for (int i = buffer.remaining(); i > 0; i--, x++) {
tikhomirov@295: 					if (x >= data.length /*file has been appended*/ || data[x] != buffer.get()) {
tikhomirov@295: 						if (debug) {
tikhomirov@295: 							byte[] xx = new byte[15];
tikhomirov@295: 							if (buffer.position() > 5) {
tikhomirov@295: 								buffer.position(buffer.position() - 5);
tikhomirov@117: 							}
tikhomirov@334: 							buffer.get(xx, 0, min(xx.length, i-1 /*-1 for the one potentially read at buffer.get in if() */));
tikhomirov@334: 							String exp;
tikhomirov@334: 							if (x < data.length) {
tikhomirov@334: 								exp = new String(data, max(0, x - 4), min(data.length - x, 20));
tikhomirov@334: 							} else {
tikhomirov@334: 								int offset = max(0, x - 4);
tikhomirov@334: 								exp = new String(data, offset, min(data.length - offset, 20));
tikhomirov@334: 							}
tikhomirov@490: 							repo.getSessionContext().getLog().dump(getClass(), Debug, "expected >>%s<< but got >>%s<<", exp, new String(xx));
tikhomirov@117: 						}
tikhomirov@295: 						sameSoFar = false;
tikhomirov@295: 						break;
tikhomirov@219: 					}
tikhomirov@117: 				}
tikhomirov@295: 				buffer.position(buffer.limit()); // mark as read
tikhomirov@295: 				return buffer.limit();
tikhomirov@295: 			}
tikhomirov@295: 			
tikhomirov@295: 			public boolean sameSoFar() {
tikhomirov@295: 				return sameSoFar;
tikhomirov@295: 			}
tikhomirov@295: 			public boolean ultimatelyTheSame() {
tikhomirov@295: 				return sameSoFar && x == data.length;
tikhomirov@295: 			}
tikhomirov@295: 		};
tikhomirov@295: 		Check check = new Check(); 
tikhomirov@295: 		try {
tikhomirov@295: 			is = f.newInputChannel();
tikhomirov@295: 			ByteBuffer fb = ByteBuffer.allocate(min(1 + data.length * 2 /*to fit couple of lines appended; never zero*/, 8192));
tikhomirov@295: 			FilterByteChannel filters = new FilterByteChannel(check, repo.getFiltersFromWorkingDirToRepo(p));
tikhomirov@356: 			Preview preview = Adaptable.Factory.getAdapter(filters, Preview.class, null);
tikhomirov@355: 			if (preview != null) {
tikhomirov@355: 				while (is.read(fb) != -1) {
tikhomirov@355: 					fb.flip();
tikhomirov@355: 					preview.preview(fb);
tikhomirov@355: 					fb.clear();
tikhomirov@355: 				}
tikhomirov@355: 				// reset channel to read once again
tikhomirov@355: 				try {
tikhomirov@355: 					is.close();
tikhomirov@355: 				} catch (IOException ex) {
tikhomirov@490: 					repo.getSessionContext().getLog().dump(getClass(), Info, ex, null);
tikhomirov@355: 				}
tikhomirov@355: 				is = f.newInputChannel();
tikhomirov@355: 				fb.clear();
tikhomirov@355: 			}
tikhomirov@295: 			while (is.read(fb) != -1 && check.sameSoFar()) {
tikhomirov@295: 				fb.flip();
tikhomirov@295: 				filters.write(fb);
tikhomirov@295: 				fb.compact();
tikhomirov@295: 			}
tikhomirov@295: 			return check.ultimatelyTheSame();
tikhomirov@295: 		} catch (CancelledException ex) {
tikhomirov@490: 			repo.getSessionContext().getLog().dump(getClass(), Warn, ex, "Unexpected cancellation");
tikhomirov@295: 			return check.ultimatelyTheSame();
tikhomirov@295: 		} catch (IOException ex) {
tikhomirov@397: 			throw new HgInvalidFileException("File comparison failed", ex).setFileName(p);
tikhomirov@295: 		} finally {
tikhomirov@654: 			new FileUtils(repo.getSessionContext().getLog(), this).closeQuietly(is);
tikhomirov@117: 		}
tikhomirov@117: 	}
tikhomirov@117: 
tikhomirov@413: 	/**
tikhomirov@413: 	 * @return <code>true</code> if flags are the same
tikhomirov@413: 	 */
tikhomirov@413: 	private boolean checkFlagsEqual(FileInfo f, HgManifest.Flags originalManifestFlags) {
tikhomirov@413: 		boolean same = true;
tikhomirov@413: 		if (repoWalker.supportsLinkFlag()) {
tikhomirov@413: 			if (originalManifestFlags == HgManifest.Flags.Link) {
tikhomirov@413: 				return f.isSymlink();
tikhomirov@413: 			}
tikhomirov@413: 			// original flag is not link, hence flags are the same if file is not link, too.
tikhomirov@413: 			same = !f.isSymlink();
tikhomirov@413: 		} // otherwise treat flags the same
tikhomirov@413: 		if (repoWalker.supportsExecFlag()) {
tikhomirov@413: 			if (originalManifestFlags == HgManifest.Flags.Exec) {
tikhomirov@413: 				return f.isExecutable();
tikhomirov@413: 			}
tikhomirov@413: 			// original flag has no executable attribute, hence file shall not be executable, too
tikhomirov@413: 			same = same || !f.isExecutable();
tikhomirov@413: 		}
tikhomirov@413: 		return same;
tikhomirov@413: 	}
tikhomirov@413: 	
tikhomirov@413: 	private boolean checkFlagsEqual(FileInfo f, int dirstateFileMode) {
tikhomirov@608: 		return checkFlagsEqual(f, HgManifest.Flags.parse(dirstateFileMode)); 
tikhomirov@58: 	}
tikhomirov@58: 
tikhomirov@229: 	/**
tikhomirov@229: 	 * Configure status collector to consider only subset of a working copy tree. Tries to be as effective as possible, and to 
tikhomirov@229: 	 * traverse only relevant part of working copy on the filesystem.
tikhomirov@229: 	 * 
tikhomirov@229: 	 * @param hgRepo repository
tikhomirov@229: 	 * @param paths repository-relative files and/or directories. Directories are processed recursively. 
tikhomirov@229: 	 * 
tikhomirov@229: 	 * @return new instance of {@link HgWorkingCopyStatusCollector}, ready to {@link #walk(int, HgStatusInspector) walk} associated working copy 
tikhomirov@229: 	 */
tikhomirov@229: 	public static HgWorkingCopyStatusCollector create(HgRepository hgRepo, Path... paths) {
tikhomirov@229: 		ArrayList<Path> f = new ArrayList<Path>(5);
tikhomirov@229: 		ArrayList<Path> d = new ArrayList<Path>(5);
tikhomirov@229: 		for (Path p : paths) {
tikhomirov@229: 			if (p.isDirectory()) {
tikhomirov@229: 				d.add(p);
tikhomirov@229: 			} else {
tikhomirov@229: 				f.add(p);
tikhomirov@229: 			}
tikhomirov@229: 		}
tikhomirov@229: //		final Path[] dirs = f.toArray(new Path[d.size()]);
tikhomirov@229: 		if (d.isEmpty()) {
tikhomirov@229: 			final Path[] files = f.toArray(new Path[f.size()]);
tikhomirov@490: 			FileIterator fi = new FileListIterator(hgRepo.getSessionContext(), hgRepo.getWorkingDir(), files);
tikhomirov@229: 			return new HgWorkingCopyStatusCollector(hgRepo, fi);
tikhomirov@229: 		}
tikhomirov@229: 		//
tikhomirov@229: 		
tikhomirov@229: 		//FileIterator fi = file.isDirectory() ? new DirFileIterator(hgRepo, file) : new FileListIterator(, file);
tikhomirov@229: 		FileIterator fi = new HgInternals(hgRepo).createWorkingDirWalker(new PathScope(true, paths));
tikhomirov@226: 		return new HgWorkingCopyStatusCollector(hgRepo, fi);
tikhomirov@226: 	}
tikhomirov@229: 	
tikhomirov@229: 	/**
tikhomirov@229: 	 * Configure collector object to calculate status for matching files only. 
tikhomirov@229: 	 * This method may be less effective than explicit list of files as it iterates over whole repository 
tikhomirov@229: 	 * (thus supplied matcher doesn't need to care if directories to files in question are also in scope, 
tikhomirov@229: 	 * see {@link FileWalker#FileWalker(File, Path.Source, Path.Matcher)})
tikhomirov@229: 	 *  
tikhomirov@229: 	 * @return new instance of {@link HgWorkingCopyStatusCollector}, ready to {@link #walk(int, HgStatusInspector) walk} associated working copy
tikhomirov@229: 	 */
tikhomirov@229: 	public static HgWorkingCopyStatusCollector create(HgRepository hgRepo, Path.Matcher scope) {
tikhomirov@229: 		FileIterator w = new HgInternals(hgRepo).createWorkingDirWalker(null);
tikhomirov@229: 		FileIterator wf = (scope == null || scope instanceof Path.Matcher.Any) ? w : new FileIteratorFilter(w, scope);
tikhomirov@229: 		// the reason I need to iterate over full repo and apply filter is that I have no idea whatsoever about
tikhomirov@229: 		// patterns in the scope. I.e. if scope lists a file (PathGlobMatcher("a/b/c.txt")), FileWalker won't get deep
tikhomirov@229: 		// to the file unless matcher would also explicitly include "a/", "a/b/" in scope. Since I can't rely
tikhomirov@229: 		// users would write robust matchers, and I don't see a decent way to enforce that (i.e. factory to produce
tikhomirov@229: 		// correct matcher from Path is much like what PathScope does, and can be accessed directly with #create(repo, Path...)
tikhomirov@229: 		// method above/
tikhomirov@229: 		return new HgWorkingCopyStatusCollector(hgRepo, wf);
tikhomirov@229: 	}
tikhomirov@226: 
tikhomirov@226: 	private static class FileListIterator implements FileIterator {
tikhomirov@226: 		private final File dir;
tikhomirov@226: 		private final Path[] paths;
tikhomirov@226: 		private int index;
tikhomirov@287: 		private RegularFileInfo nextFile;
tikhomirov@413: 		private final boolean execCap, linkCap;
tikhomirov@425: 		private final SessionContext sessionContext;
tikhomirov@226: 
tikhomirov@425: 		public FileListIterator(SessionContext ctx, File startDir, Path... files) {
tikhomirov@425: 			sessionContext = ctx;
tikhomirov@226: 			dir = startDir;
tikhomirov@226: 			paths = files;
tikhomirov@226: 			reset();
tikhomirov@413: 			execCap = Internals.checkSupportsExecutables(startDir);
tikhomirov@413: 			linkCap = Internals.checkSupportsSymlinks(startDir);
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public void reset() {
tikhomirov@226: 			index = -1;
tikhomirov@425: 			nextFile = new RegularFileInfo(sessionContext, execCap, linkCap);
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public boolean hasNext() {
tikhomirov@226: 			return paths.length > 0 && index < paths.length-1;
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public void next() {
tikhomirov@226: 			index++;
tikhomirov@226: 			if (index == paths.length) {
tikhomirov@226: 				throw new NoSuchElementException();
tikhomirov@226: 			}
tikhomirov@287: 			nextFile.init(new File(dir, paths[index].toString()));
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public Path name() {
tikhomirov@226: 			return paths[index];
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@287: 		public FileInfo file() {
tikhomirov@226: 			return nextFile;
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public boolean inScope(Path file) {
tikhomirov@226: 			for (int i = 0; i < paths.length; i++) {
tikhomirov@226: 				if (paths[i].equals(file)) {
tikhomirov@226: 					return true;
tikhomirov@226: 				}
tikhomirov@226: 			}
tikhomirov@226: 			return false;
tikhomirov@226: 		}
tikhomirov@413: 		
tikhomirov@413: 		public boolean supportsExecFlag() {
tikhomirov@423: 			return execCap;
tikhomirov@413: 		}
tikhomirov@413: 		
tikhomirov@413: 		public boolean supportsLinkFlag() {
tikhomirov@423: 			return linkCap;
tikhomirov@413: 		}
tikhomirov@226: 	}
tikhomirov@226: 	
tikhomirov@229: 	private static class FileIteratorFilter implements FileIterator {
tikhomirov@229: 		private final Path.Matcher filter;
tikhomirov@229: 		private final FileIterator walker;
tikhomirov@229: 		private boolean didNext = false;
tikhomirov@226: 
tikhomirov@229: 		public FileIteratorFilter(FileIterator fileWalker, Path.Matcher filterMatcher) {
tikhomirov@229: 			assert fileWalker != null;
tikhomirov@229: 			assert filterMatcher != null;
tikhomirov@229: 			filter = filterMatcher;
tikhomirov@229: 			walker = fileWalker;
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@350: 		public void reset() throws IOException {
tikhomirov@226: 			walker.reset();
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@350: 		public boolean hasNext() throws IOException {
tikhomirov@229: 			while (walker.hasNext()) {
tikhomirov@229: 				walker.next();
tikhomirov@229: 				if (filter.accept(walker.name())) {
tikhomirov@229: 					didNext = true;
tikhomirov@229: 					return true;
tikhomirov@229: 				}
tikhomirov@229: 			}
tikhomirov@229: 			return false;
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@350: 		public void next() throws IOException {
tikhomirov@229: 			if (didNext) {
tikhomirov@229: 				didNext = false;
tikhomirov@229: 			} else {
tikhomirov@229: 				if (!hasNext()) {
tikhomirov@229: 					throw new NoSuchElementException();
tikhomirov@229: 				}
tikhomirov@229: 			}
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public Path name() {
tikhomirov@226: 			return walker.name();
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@287: 		public FileInfo file() {
tikhomirov@226: 			return walker.file();
tikhomirov@226: 		}
tikhomirov@226: 
tikhomirov@226: 		public boolean inScope(Path file) {
tikhomirov@229: 			return filter.accept(file);
tikhomirov@226: 		}
tikhomirov@413: 		
tikhomirov@413: 		public boolean supportsExecFlag() {
tikhomirov@413: 			return walker.supportsExecFlag();
tikhomirov@413: 		}
tikhomirov@413: 		
tikhomirov@413: 		public boolean supportsLinkFlag() {
tikhomirov@413: 			return walker.supportsLinkFlag();
tikhomirov@413: 		}
tikhomirov@226: 	}
tikhomirov@58: }