org.eclipse.jgit/src/org/eclipse/jgit/revwalk/DepthWalk.java - jgit - Git at Google

 /*
  * Copyright (C) 2010, Garmin International
  * Copyright (C) 2010, Matt Fischer <matt.fischer@garmin.com> and others
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Distribution License v. 1.0 which is available at
  * https://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */

 package org.eclipse.jgit.revwalk;

 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;

 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.lib.AnyObjectId;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.lib.Repository;

 /**
  * Interface for revision walkers that perform depth filtering.
  */
 public interface DepthWalk {
 	/**
 	 * Get depth to filter to.
 	 *
 	 * @return Depth to filter to.
 	 */
 	int getDepth();

 	/**
 	 * @return the deepen-since value; if not 0, this walk only returns commits
 	 *         whose commit time is at or after this limit
 	 * @since 5.2
 	 */
 	default int getDeepenSince() {
 		return 0;
 	}

 	/**
 	 * @return the objects specified by the client using --shallow-exclude
 	 * @since 5.2
 	 */
 	default List<ObjectId> getDeepenNots() {
 		return Collections.emptyList();
 	}

 	/** @return flag marking commits that should become unshallow. */
 	/**
 	 * Get flag marking commits that should become unshallow.
 	 *
 	 * @return flag marking commits that should become unshallow.
 	 */
 	RevFlag getUnshallowFlag();

 	/**
 	 * Get flag marking commits that are interesting again.
 	 *
 	 * @return flag marking commits that are interesting again.
 	 */
 	RevFlag getReinterestingFlag();

 	/**
 	 * @return flag marking commits that are to be excluded because of --shallow-exclude
 	 * @since 5.2
 	 */
 	RevFlag getDeepenNotFlag();

 	/** RevCommit with a depth (in commits) from a root. */
 	public static class Commit extends RevCommit {
 		/** Depth of this commit in the graph, via shortest path. */
 		int depth;

 		boolean isBoundary;

 		/**
 		 * True if this commit was excluded due to a shallow fetch
 		 * setting. All its children are thus boundary commits.
 		 */
 		boolean makesChildBoundary;

 		/** @return depth of this commit, as found by the shortest path. */
 		public int getDepth() {
 			return depth;
 		}

 		/**
 		 * @return true if at least one of this commit's parents was excluded
 		 *         due to a shallow fetch setting, false otherwise
 		 * @since 5.2
 		 */
 		public boolean isBoundary() {
 			return isBoundary;
 		}

 		/**
 		 * Initialize a new commit.
 		 *
 		 * @param id
 		 *            object name for the commit.
 		 */
 		protected Commit(AnyObjectId id) {
 			super(id);
 			depth = -1;
 		}
 	}

 	/** Subclass of RevWalk that performs depth filtering. */
 	public class RevWalk extends org.eclipse.jgit.revwalk.RevWalk implements DepthWalk {
 		private final int depth;

 		private int deepenSince;

 		private List<ObjectId> deepenNots;

 		private final RevFlag UNSHALLOW;

 		private final RevFlag REINTERESTING;

 		private final RevFlag DEEPEN_NOT;

 		/**
 		 * @param repo Repository to walk
 		 * @param depth Maximum depth to return
 		 */
 		public RevWalk(Repository repo, int depth) {
 			super(repo);

 			this.depth = depth;
 			this.deepenNots = Collections.emptyList();
 			this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
 			this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
 			this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
 		}

 		/**
 		 * @param or ObjectReader to use
 		 * @param depth Maximum depth to return
 		 */
 		public RevWalk(ObjectReader or, int depth) {
 			super(or);

 			this.depth = depth;
 			this.deepenNots = Collections.emptyList();
 			this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
 			this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
 			this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
 		}

 		/**
 		 * Mark a root commit (i.e., one whose depth should be considered 0.)
 		 *
 		 * @param c
 		 *            Commit to mark
 		 * @throws IOException
 		 * @throws IncorrectObjectTypeException
 		 * @throws MissingObjectException
 		 */
 		public void markRoot(RevCommit c) throws MissingObjectException,
 				IncorrectObjectTypeException, IOException {
 			if (c instanceof Commit)
 				((Commit) c).depth = 0;
 			super.markStart(c);
 		}

 		@Override
 		protected RevCommit createCommit(AnyObjectId id) {
 			return new Commit(id);
 		}

 		@Override
 		public int getDepth() {
 			return depth;
 		}

 		@Override
 		public int getDeepenSince() {
 			return deepenSince;
 		}

 		/**
 		 * Sets the deepen-since value.
 		 *
 		 * @param limit
 		 *            new deepen-since value
 		 * @since 5.2
 		 */
 		public void setDeepenSince(int limit) {
 			deepenSince = limit;
 		}

 		@Override
 		public List<ObjectId> getDeepenNots() {
 			return deepenNots;
 		}

 		/**
 		 * Mark objects that the client specified using
 		 * --shallow-exclude. Objects that are not commits have no
 		 * effect.
 		 *
 		 * @param deepenNots specified objects
 		 * @since 5.2
 		 */
 		public void setDeepenNots(List<ObjectId> deepenNots) {
 			this.deepenNots = Objects.requireNonNull(deepenNots);
 		}

 		@Override
 		public RevFlag getUnshallowFlag() {
 			return UNSHALLOW;
 		}

 		@Override
 		public RevFlag getReinterestingFlag() {
 			return REINTERESTING;
 		}

 		@Override
 		public RevFlag getDeepenNotFlag() {
 			return DEEPEN_NOT;
 		}

 		/**
 		 * @since 4.5
 		 */
 		@Override
 		public ObjectWalk toObjectWalkWithSameObjects() {
 			ObjectWalk ow = new ObjectWalk(reader, depth);
 			ow.deepenSince = deepenSince;
 			ow.deepenNots = deepenNots;
 			ow.objects = objects;
 			ow.freeFlags = freeFlags;
 			return ow;
 		}
 	}

 	/** Subclass of ObjectWalk that performs depth filtering. */
 	public class ObjectWalk extends org.eclipse.jgit.revwalk.ObjectWalk implements DepthWalk {
 		private final int depth;

 		private int deepenSince;

 		private List<ObjectId> deepenNots;

 		private final RevFlag UNSHALLOW;

 		private final RevFlag REINTERESTING;

 		private final RevFlag DEEPEN_NOT;

 		/**
 		 * @param repo Repository to walk
 		 * @param depth Maximum depth to return
 		 */
 		public ObjectWalk(Repository repo, int depth) {
 			super(repo);

 			this.depth = depth;
 			this.deepenNots = Collections.emptyList();
 			this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
 			this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
 			this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
 		}

 		/**
 		 * @param or Object Reader
 		 * @param depth Maximum depth to return
 		 */
 		public ObjectWalk(ObjectReader or, int depth) {
 			super(or);

 			this.depth = depth;
 			this.deepenNots = Collections.emptyList();
 			this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
 			this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
 			this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
 		}

 		/**
 		 * Mark a root commit (i.e., one whose depth should be considered 0.)
 		 *
 		 * @param o
 		 *            Commit to mark
 		 * @throws IOException
 		 * @throws IncorrectObjectTypeException
 		 * @throws MissingObjectException
 		 */
 		public void markRoot(RevObject o) throws MissingObjectException,
 				IncorrectObjectTypeException, IOException {
 			RevObject c = o;
 			while (c instanceof RevTag) {
 				c = ((RevTag) c).getObject();
 				parseHeaders(c);
 			}
 			if (c instanceof Commit)
 				((Commit) c).depth = 0;
 			super.markStart(o);
 		}

 		/**
 		 * Mark an element which used to be shallow in the client, but which
 		 * should now be considered a full commit. Any ancestors of this commit
 		 * should be included in the walk, even if they are the ancestor of an
 		 * uninteresting commit.
 		 *
 		 * @param c
 		 *            Commit to mark
 		 * @throws MissingObjectException
 		 * @throws IncorrectObjectTypeException
 		 * @throws IOException
 		 */
 		public void markUnshallow(RevObject c) throws MissingObjectException,
 				IncorrectObjectTypeException, IOException {
 			if (c instanceof RevCommit)
 				c.add(UNSHALLOW);
 			super.markStart(c);
 		}

 		@Override
 		protected RevCommit createCommit(AnyObjectId id) {
 			return new Commit(id);
 		}

 		@Override
 		public int getDepth() {
 			return depth;
 		}

 		@Override
 		public int getDeepenSince() {
 			return deepenSince;
 		}

 		@Override
 		public List<ObjectId> getDeepenNots() {
 			return deepenNots;
 		}

 		@Override
 		public RevFlag getUnshallowFlag() {
 			return UNSHALLOW;
 		}

 		@Override
 		public RevFlag getReinterestingFlag() {
 			return REINTERESTING;
 		}

 		@Override
 		public RevFlag getDeepenNotFlag() {
 			return DEEPEN_NOT;
 		}
 	}
 }
	/*
	* Copyright (C) 2010, Garmin International
	* Copyright (C) 2010, Matt Fischer <matt.fischer@garmin.com> and others
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Distribution License v. 1.0 which is available at
	* https://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	package org.eclipse.jgit.revwalk;

	import java.io.IOException;
	import java.util.Collections;
	import java.util.List;
	import java.util.Objects;

	import org.eclipse.jgit.errors.IncorrectObjectTypeException;
	import org.eclipse.jgit.errors.MissingObjectException;
	import org.eclipse.jgit.lib.AnyObjectId;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.ObjectReader;
	import org.eclipse.jgit.lib.Repository;

	/**
	* Interface for revision walkers that perform depth filtering.
	*/
	public interface DepthWalk {
	/**
	* Get depth to filter to.
	*
	* @return Depth to filter to.
	*/
	int getDepth();

	/**
	* @return the deepen-since value; if not 0, this walk only returns commits
	* whose commit time is at or after this limit
	* @since 5.2
	*/
	default int getDeepenSince() {
	return 0;
	}

	/**
	* @return the objects specified by the client using --shallow-exclude
	* @since 5.2
	*/
	default List<ObjectId> getDeepenNots() {
	return Collections.emptyList();
	}

	/** @return flag marking commits that should become unshallow. */
	/**
	* Get flag marking commits that should become unshallow.
	*
	* @return flag marking commits that should become unshallow.
	*/
	RevFlag getUnshallowFlag();

	/**
	* Get flag marking commits that are interesting again.
	*
	* @return flag marking commits that are interesting again.
	*/
	RevFlag getReinterestingFlag();

	/**
	* @return flag marking commits that are to be excluded because of --shallow-exclude
	* @since 5.2
	*/
	RevFlag getDeepenNotFlag();

	/** RevCommit with a depth (in commits) from a root. */
	public static class Commit extends RevCommit {
	/** Depth of this commit in the graph, via shortest path. */
	int depth;

	boolean isBoundary;

	/**
	* True if this commit was excluded due to a shallow fetch
	* setting. All its children are thus boundary commits.
	*/
	boolean makesChildBoundary;

	/** @return depth of this commit, as found by the shortest path. */
	public int getDepth() {
	return depth;
	}

	/**
	* @return true if at least one of this commit's parents was excluded
	* due to a shallow fetch setting, false otherwise
	* @since 5.2
	*/
	public boolean isBoundary() {
	return isBoundary;
	}

	/**
	* Initialize a new commit.
	*
	* @param id
	* object name for the commit.
	*/
	protected Commit(AnyObjectId id) {
	super(id);
	depth = -1;
	}
	}

	/** Subclass of RevWalk that performs depth filtering. */
	public class RevWalk extends org.eclipse.jgit.revwalk.RevWalk implements DepthWalk {
	private final int depth;

	private int deepenSince;

	private List<ObjectId> deepenNots;

	private final RevFlag UNSHALLOW;

	private final RevFlag REINTERESTING;

	private final RevFlag DEEPEN_NOT;

	/**
	* @param repo Repository to walk
	* @param depth Maximum depth to return
	*/
	public RevWalk(Repository repo, int depth) {
	super(repo);

	this.depth = depth;
	this.deepenNots = Collections.emptyList();
	this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
	this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
	this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
	}

	/**
	* @param or ObjectReader to use
	* @param depth Maximum depth to return
	*/
	public RevWalk(ObjectReader or, int depth) {
	super(or);

	this.depth = depth;
	this.deepenNots = Collections.emptyList();
	this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
	this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
	this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
	}

	/**
	* Mark a root commit (i.e., one whose depth should be considered 0.)
	*
	* @param c
	* Commit to mark
	* @throws IOException
	* @throws IncorrectObjectTypeException
	* @throws MissingObjectException
	*/
	public void markRoot(RevCommit c) throws MissingObjectException,
	IncorrectObjectTypeException, IOException {
	if (c instanceof Commit)
	((Commit) c).depth = 0;
	super.markStart(c);
	}

	@Override
	protected RevCommit createCommit(AnyObjectId id) {
	return new Commit(id);
	}

	@Override
	public int getDepth() {
	return depth;
	}

	@Override
	public int getDeepenSince() {
	return deepenSince;
	}

	/**
	* Sets the deepen-since value.
	*
	* @param limit
	* new deepen-since value
	* @since 5.2
	*/
	public void setDeepenSince(int limit) {
	deepenSince = limit;
	}

	@Override
	public List<ObjectId> getDeepenNots() {
	return deepenNots;
	}

	/**
	* Mark objects that the client specified using
	* --shallow-exclude. Objects that are not commits have no
	* effect.
	*
	* @param deepenNots specified objects
	* @since 5.2
	*/
	public void setDeepenNots(List<ObjectId> deepenNots) {
	this.deepenNots = Objects.requireNonNull(deepenNots);
	}

	@Override
	public RevFlag getUnshallowFlag() {
	return UNSHALLOW;
	}

	@Override
	public RevFlag getReinterestingFlag() {
	return REINTERESTING;
	}

	@Override
	public RevFlag getDeepenNotFlag() {
	return DEEPEN_NOT;
	}

	/**
	* @since 4.5
	*/
	@Override
	public ObjectWalk toObjectWalkWithSameObjects() {
	ObjectWalk ow = new ObjectWalk(reader, depth);
	ow.deepenSince = deepenSince;
	ow.deepenNots = deepenNots;
	ow.objects = objects;
	ow.freeFlags = freeFlags;
	return ow;
	}
	}

	/** Subclass of ObjectWalk that performs depth filtering. */
	public class ObjectWalk extends org.eclipse.jgit.revwalk.ObjectWalk implements DepthWalk {
	private final int depth;

	private int deepenSince;

	private List<ObjectId> deepenNots;

	private final RevFlag UNSHALLOW;

	private final RevFlag REINTERESTING;

	private final RevFlag DEEPEN_NOT;

	/**
	* @param repo Repository to walk
	* @param depth Maximum depth to return
	*/
	public ObjectWalk(Repository repo, int depth) {
	super(repo);

	this.depth = depth;
	this.deepenNots = Collections.emptyList();
	this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
	this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
	this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
	}

	/**
	* @param or Object Reader
	* @param depth Maximum depth to return
	*/
	public ObjectWalk(ObjectReader or, int depth) {
	super(or);

	this.depth = depth;
	this.deepenNots = Collections.emptyList();
	this.UNSHALLOW = newFlag("UNSHALLOW"); //$NON-NLS-1$
	this.REINTERESTING = newFlag("REINTERESTING"); //$NON-NLS-1$
	this.DEEPEN_NOT = newFlag("DEEPEN_NOT"); //$NON-NLS-1$
	}

	/**
	* Mark a root commit (i.e., one whose depth should be considered 0.)
	*
	* @param o
	* Commit to mark
	* @throws IOException
	* @throws IncorrectObjectTypeException
	* @throws MissingObjectException
	*/
	public void markRoot(RevObject o) throws MissingObjectException,
	IncorrectObjectTypeException, IOException {
	RevObject c = o;
	while (c instanceof RevTag) {
	c = ((RevTag) c).getObject();
	parseHeaders(c);
	}
	if (c instanceof Commit)
	((Commit) c).depth = 0;
	super.markStart(o);
	}

	/**
	* Mark an element which used to be shallow in the client, but which
	* should now be considered a full commit. Any ancestors of this commit
	* should be included in the walk, even if they are the ancestor of an
	* uninteresting commit.
	*
	* @param c
	* Commit to mark
	* @throws MissingObjectException
	* @throws IncorrectObjectTypeException
	* @throws IOException
	*/
	public void markUnshallow(RevObject c) throws MissingObjectException,
	IncorrectObjectTypeException, IOException {
	if (c instanceof RevCommit)
	c.add(UNSHALLOW);
	super.markStart(c);
	}

	@Override
	protected RevCommit createCommit(AnyObjectId id) {
	return new Commit(id);
	}

	@Override
	public int getDepth() {
	return depth;
	}

	@Override
	public int getDeepenSince() {
	return deepenSince;
	}

	@Override
	public List<ObjectId> getDeepenNots() {
	return deepenNots;
	}

	@Override
	public RevFlag getUnshallowFlag() {
	return UNSHALLOW;
	}

	@Override
	public RevFlag getReinterestingFlag() {
	return REINTERESTING;
	}

	@Override
	public RevFlag getDeepenNotFlag() {
	return DEEPEN_NOT;
	}
	}
	}