jhg: src/org/tmatesoft/hg/core/HgLogCommand.java comparison

comparison src/org/tmatesoft/hg/core/HgLogCommand.java @ 423:9c9c442b5f2e

Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Fri, 23 Mar 2012 22:51:18 +0100
parents	7f136a3fa671
children	6437d261048a

comparison

equal deleted inserted replaced

-:5d1cc7366d04
+:9c9c442b5f2e
 import org.tmatesoft.hg.internal.IntVector;
 import org.tmatesoft.hg.repo.HgChangelog;
 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset;
 import org.tmatesoft.hg.repo.HgDataFile;
 import org.tmatesoft.hg.repo.HgInternals;
+import org.tmatesoft.hg.repo.HgInvalidControlFileException;
+import org.tmatesoft.hg.repo.HgInvalidRevisionException;
+import org.tmatesoft.hg.repo.HgInvalidStateException;
 import org.tmatesoft.hg.repo.HgRepository;
+import org.tmatesoft.hg.repo.HgRuntimeException;
 import org.tmatesoft.hg.repo.HgStatusCollector;
 import org.tmatesoft.hg.util.CancelSupport;
 import org.tmatesoft.hg.util.CancelledException;
 import org.tmatesoft.hg.util.Pair;
 import org.tmatesoft.hg.util.Path;
 		return file(Path.create(repo.getToRepoPathHelper().rewrite(file)), followCopyRename);
 	}
 	/**
 	 * Similar to {@link #execute(HgChangesetHandler)}, collects and return result as a list.
+	 * @throws HgException FIXME EXCEPTIONS
 	 */
 	public List<HgChangeset> execute() throws HgException {
 		CollectHandler collector = new CollectHandler();
 		try {
 			execute(collector);
+		} catch (HgCallbackTargetException ex) {
+			// see below for CanceledException
+			HgInvalidStateException t = new HgInvalidStateException("Internal error");
+			t.initCause(ex);
+			throw t;
 		} catch (CancelledException ex) {
 			// can't happen as long as our CollectHandler doesn't throw any exception
-			throw new HgBadStateException(ex);
+			HgInvalidStateException t = new HgInvalidStateException("Internal error");
+			t.initCause(ex);
+			throw t;
 		}
 		return collector.getChanges();
 	}
 	/**
 	 * Iterate over range of changesets configured in the command.
 	 *
 	 * @param handler callback to process changesets.
-	 * @throws HgCallbackTargetException to re-throw exception from the handler
+	 * @throws HgCallbackTargetException wrapper for any exception user callback code may produce
 	 * @throws HgInvalidControlFileException if access to revlog index/data entry failed
 	 * @throws HgException in case of some other library issue
 	 * @throws CancelledException if execution of the command was cancelled
 	 * @throws IllegalArgumentException when inspector argument is null
 	 * @throws ConcurrentModificationException if this log command instance is already running
 					// even if we do not follow history, report file rename
 					do {
 						if (handler instanceof FileHistoryHandler) {
 							HgFileRevision src = new HgFileRevision(repo, fileNode.getCopySourceRevision(), null, fileNode.getCopySourceName());
 							HgFileRevision dst = new HgFileRevision(repo, fileNode.getRevision(0), null, fileNode.getPath(), src.getPath());
-							try {
+							((FileHistoryHandler) handler).copy(src, dst);
-								((FileHistoryHandler) handler).copy(src, dst);
-							} catch (HgCallbackTargetException.Wrap ex) {
-								throw new HgCallbackTargetException(ex).setRevision(fileNode.getCopySourceRevision()).setFileName(fileNode.getCopySourceName());
-							}
 						}
 						if (limit > 0 && count >= limit) {
 							// if limit reach, follow is useless.
 							break;
 						}
 			progressHelper.worked(1);
 			ph2 = new ProgressSupport.Sub(progressHelper, 2);
 		} else {
 			ph2 = new ProgressSupport.Sub(progressHelper, 3);
 		}
-		try {
+		ph2.start(completeHistory.length);
-			ph2.start(completeHistory.length);
+		// XXX shall sort completeHistory according to changeset numbers?
-			// XXX shall sort completeHistory according to changeset numbers?
+		for (int i = 0; i < completeHistory.length; i++ ) {
-			for (int i = 0; i < completeHistory.length; i++ ) {
+			final HistoryNode n = completeHistory[i];
-				final HistoryNode n = completeHistory[i];
+			handler.next(ei.init(n));
-				handler.next(ei.init(n));
+			ph2.worked(1);
-				ph2.worked(1);
+			cancelHelper.checkCancelled();
-				cancelHelper.checkCancelled();
-			}
-		} catch (HgCallbackTargetException.Wrap ex) {
-			throw new HgCallbackTargetException(ex);
 		}
 		progressHelper.done();
 	}
 	//
 	 * @author TMate Software Ltd.
 	 */
 	public interface FileHistoryHandler extends HgChangesetHandler { // FIXME move to stanalone class file, perhaps?
 		// XXX perhaps, should distinguish copy from rename? And what about merged revisions and following them?
 		/**
-		 * @throws HgCallbackTargetException.Wrap wrapper object for any exception user code may produce. Wrapped exception would get re-thrown with {@link HgCallbackTargetException}
+		 * @throws HgCallbackTargetException wrapper object for any exception user code may produce
 		 */
-		void copy(HgFileRevision from, HgFileRevision to) throws HgCallbackTargetException.Wrap;
+		void copy(HgFileRevision from, HgFileRevision to) throws HgCallbackTargetException;
 	}
 	public static class CollectHandler implements HgChangesetHandler {
 		private final List<HgChangeset> result = new LinkedList<HgChangeset>();
 		public Nodeid fileRevision() {
 			return historyNode.fileRevision;
 		}
-		public HgChangeset changeset() throws HgException {
+		public HgChangeset changeset() {
 			return get(historyNode.changeset)[0];
 		}
-		public Pair<HgChangeset, HgChangeset> parents() throws HgException {
+		public Pair<HgChangeset, HgChangeset> parents() {
 			if (parents != null) {
 				return parents;
 			}
 			HistoryNode p;
 			final int p1, p2;
 			}
 			HgChangeset[] r = get(p1, p2);
 			return parents = new Pair<HgChangeset, HgChangeset>(r[0], r[1]);
 		}
-		public Collection<HgChangeset> children() throws HgException {
+		public Collection<HgChangeset> children() {
 			if (children != null) {
 				return children;
 			}
 			if (historyNode.children == null) {
 				children = Collections.emptyList();
 		void populate(HgChangeset cs) {
 			cachedChangesets.put(cs.getRevisionIndex(), cs);
 		}
-		private HgChangeset[] get(int... changelogRevisionIndex) throws HgException {
+		private HgChangeset[] get(int... changelogRevisionIndex) {
 			HgChangeset[] rv = new HgChangeset[changelogRevisionIndex.length];
 			IntVector misses = new IntVector(changelogRevisionIndex.length, -1);
 			for (int i = 0; i < changelogRevisionIndex.length; i++) {
 				if (changelogRevisionIndex[i] == -1) {
 					rv[i] = null;
 				initTransform();
 				repo.getChangelog().range(this, changesets2read);
 				for (int changeset2read : changesets2read) {
 					HgChangeset cs = cachedChangesets.get(changeset2read);
 					if (cs == null) {
-						throw new HgException(String.format("Can't get changeset for revision %d", changeset2read));
+						HgInvalidStateException t = new HgInvalidStateException(String.format("Can't get changeset for revision %d", changeset2read));
+						throw t.setRevisionIndex(changeset2read);
 					}
 					// HgChangelog.range may reorder changesets according to their order in the changelog
 					// thus need to find original index
 					boolean sanity = false;
 					for (int i = 0; i < changelogRevisionIndex.length; i++) {
 			}
 			return rv;
 		}
 		// init only when needed
-		void initTransform() throws HgInvalidControlFileException {
+		void initTransform() throws HgRuntimeException {
 			if (transform == null) {
 				transform = new ChangesetTransformer.Transformation(new HgStatusCollector(repo)/*XXX try to reuse from context?*/, getParentHelper(false));
 			}
 		}
 		public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) {
 			HgChangeset cs = transform.handle(revisionNumber, nodeid, cset);
 			populate(cs.clone());
 		}
-		public Nodeid changesetRevision() throws HgException {
+		public Nodeid changesetRevision() {
 			if (changesetRevision == null) {
 				changesetRevision = getRevision(historyNode.changeset);
 			}
 			return changesetRevision;
 		}
-		public Pair<Nodeid, Nodeid> parentRevisions() throws HgException {
+		public Pair<Nodeid, Nodeid> parentRevisions() {
 			if (parentRevisions == null) {
 				HistoryNode p;
 				final Nodeid p1, p2;
 				if ((p = historyNode.parent1) != null) {
 					p1 = getRevision(p.changeset);
 				parentRevisions = new Pair<Nodeid, Nodeid>(p1, p2);
 			}
 			return parentRevisions;
 		}
-		public Collection<Nodeid> childRevisions() throws HgException {
+		public Collection<Nodeid> childRevisions() {
 			if (childRevisions != null) {
 				return childRevisions;
 			}
 			if (historyNode.children == null) {
 				childRevisions = Collections.emptyList();
 			}
 			return childRevisions;
 		}
 		// reading nodeid involves reading index only, guess, can afford not to optimize multiple reads
-		private Nodeid getRevision(int changelogRevisionNumber) throws HgInvalidControlFileException {
+		private Nodeid getRevision(int changelogRevisionNumber) {
-			// TODO [post-1.0] pipe through pool
+			// TODO post-1.0 pipe through pool
 			HgChangeset cs = cachedChangesets.get(changelogRevisionNumber);
 			if (cs != null) {
 				return cs.getNodeid();
 			} else {
 				return repo.getChangelog().getRevision(changelogRevisionNumber);

Mercurial > jhg

comparison src/org/tmatesoft/hg/core/HgLogCommand.java @ 423:9c9c442b5f2e