View Javadoc
1   /*
2    * Copyright (C) 2012, Google Inc.
3    * and other copyright owners as documented in the project's IP log.
4    *
5    * This program and the accompanying materials are made available
6    * under the terms of the Eclipse Distribution License v1.0 which
7    * accompanies this distribution, is reproduced below, and is
8    * available at http://www.eclipse.org/org/documents/edl-v10.php
9    *
10   * All rights reserved.
11   *
12   * Redistribution and use in source and binary forms, with or
13   * without modification, are permitted provided that the following
14   * conditions are met:
15   *
16   * - Redistributions of source code must retain the above copyright
17   *   notice, this list of conditions and the following disclaimer.
18   *
19   * - Redistributions in binary form must reproduce the above
20   *   copyright notice, this list of conditions and the following
21   *   disclaimer in the documentation and/or other materials provided
22   *   with the distribution.
23   *
24   * - Neither the name of the Eclipse Foundation, Inc. nor the
25   *   names of its contributors may be used to endorse or promote
26   *   products derived from this software without specific prior
27   *   written permission.
28   *
29   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
30   * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
31   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
32   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
34   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
35   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
36   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
37   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
38   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
40   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
41   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42   */
43  
44  package org.eclipse.jgit.lib;
45  
46  import java.util.Iterator;
47  
48  import org.eclipse.jgit.internal.storage.file.PackBitmapIndex;
49  
50  /**
51   * A compressed bitmap representation of the entire object graph.
52   *
53   * @since 3.0
54   */
55  public interface BitmapIndex {
56  	/**
57  	 * Get the bitmap for the id. The returned bitmap is immutable and the
58  	 * bitwise operations return the result of the operation in a new Bitmap.
59  	 *
60  	 * @param objectId
61  	 *            the object ID
62  	 * @return the Bitmap for the objectId or null, if one does not exist.
63  	 */
64  	Bitmap getBitmap(AnyObjectId objectId);
65  
66  	/** @return a new {@code BitmapBuilder} based on the values in the index. */
67  	BitmapBuilder newBitmapBuilder();
68  
69  	/**
70  	 * A bitmap representation of ObjectIds that can be iterated to return the
71  	 * underlying {@code ObjectId}s or operated on with other {@code Bitmap}s.
72  	 */
73  	public interface Bitmap extends Iterable<BitmapObject> {
74  		/**
75  		 * Bitwise-OR the current bitmap with the value from the other
76  		 * bitmap.
77  		 *
78  		 * @param other
79  		 *            the other bitmap
80  		 * @return a bitmap that is the bitwise-OR.
81  		 */
82  		Bitmap or(Bitmap other);
83  
84  		/**
85  		 * Bitwise-AND-NOT the current bitmap with the value from the other
86  		 * bitmap.
87  		 *
88  		 * @param other
89  		 *            the other bitmap
90  		 * @return a bitmap that is the bitwise-AND-NOT.
91  		 */
92  		Bitmap andNot(Bitmap other);
93  
94  		/**
95  		 * Bitwise-XOR the current bitmap with the value from the other
96  		 * bitmap.
97  		 *
98  		 * @param other
99  		 *            the other bitmap
100 		 * @return a bitmap that is the bitwise-XOR.
101 		 */
102 		Bitmap xor(Bitmap other);
103 
104 		/**
105 		 * Returns an iterator over a set of elements of type BitmapObject. The
106 		 * BitmapObject instance is reused across calls to
107 		 * {@link Iterator#next()} for performance reasons.
108 		 *
109 		 * @return an Iterator.
110 		 */
111 		Iterator<BitmapObject> iterator();
112 	}
113 
114 	/**
115 	 * A builder for a bitmap. The bitwise operations update the builder and
116 	 * return a reference to the current builder.
117 	 */
118 	public interface BitmapBuilder extends Bitmap {
119 		/**
120 		 * Adds the id and the existing bitmap for the id, if one exists, to the
121 		 * bitmap.
122 		 *
123 		 * @param objectId
124 		 *            the object ID
125 		 * @param type
126 		 *            the Git object type. See {@link Constants}.
127 		 * @return true if the value was not contained or able to be loaded.
128 		 */
129 		boolean add(AnyObjectId objectId, int type);
130 
131 		/**
132 		 * Whether the bitmap has the id set.
133 		 *
134 		 * @param objectId
135 		 *            the object ID
136 		 * @return whether the bitmap currently contains the object ID
137 		 */
138 		boolean contains(AnyObjectId objectId);
139 
140 		/**
141 		 * Remove the id from the bitmap.
142 		 *
143 		 * @param objectId
144 		 *            the object ID
145 		 */
146 		void remove(AnyObjectId objectId);
147 
148 		/**
149 		 * Bitwise-OR the current bitmap with the value from the other bitmap.
150 		 *
151 		 * @param other
152 		 *            the other bitmap
153 		 * @return the current builder.
154 		 */
155 		BitmapBuilder or(Bitmap other);
156 
157 		/**
158 		 * Bitwise-AND-NOT the current bitmap with the value from the other
159 		 * bitmap.
160 		 *
161 		 * @param other
162 		 *            the other bitmap
163 		 * @return the current builder.
164 		 */
165 		BitmapBuilder andNot(Bitmap other);
166 
167 		/**
168 		 * Bitwise-XOR the current bitmap with the value from the other bitmap.
169 		 *
170 		 * @param other
171 		 *            the other bitmap
172 		 * @return the current builder.
173 		 */
174 		BitmapBuilder xor(Bitmap other);
175 
176 		/** @return the fully built immutable bitmap */
177 		Bitmap build();
178 
179 		/**
180 		 * Determines if the entire bitmap index is contained in the bitmap. If
181 		 * it is, the matching bits are removed from the bitmap and true is
182 		 * returned. If the bitmap index is null, false is returned.
183 		 *
184 		 * @param bitmapIndex
185 		 *            the bitmap index to check if it is completely contained
186 		 *            inside of the current bitmap.
187 		 * @return {@code true} if the bitmap index was a complete match.
188 		 */
189 		boolean removeAllOrNone(PackBitmapIndex bitmapIndex);
190 
191 		/** @return the number of elements in the bitmap. */
192 		int cardinality();
193 	}
194 }