* An object database stores one or more Git objects, indexed by their unique * {@link ObjectId}. Optionally an object database can reference one or more * alternates; other ObjectDatabase instances that are searched in addition to * the current database. *
* Databases are usually divided into two halves: a half that is considered to
* be fast to search, and a half that is considered to be slow to search. When
* alternates are present the fast half is fully searched (recursively through
* all alternates) before the slow half is considered.
*/
public abstract class ObjectDatabase {
/** Constant indicating no alternate databases exist. */
protected static final ObjectDatabase[] NO_ALTERNATES = {};
private final AtomicReference
* To fully close this database and its referenced alternates, the caller
* should instead invoke {@link #close()}.
*/
public void closeSelf() {
// Assume no action is required.
}
/** Fully close all loaded alternates and clear the alternate list. */
public final void closeAlternates() {
ObjectDatabase[] alt = alternates.get();
if (alt != null) {
alternates.set(null);
closeAlternates(alt);
}
}
/**
* Does the requested object exist in this database?
*
* Alternates (if present) are searched automatically.
*
* @param objectId
* identity of the object to test for existence of.
* @return true if the specified object is stored in this database, or any
* of the alternate databases.
*/
public final boolean hasObject(final AnyObjectId objectId) {
return hasObjectImpl1(objectId) || hasObjectImpl2(objectId.name());
}
private final boolean hasObjectImpl1(final AnyObjectId objectId) {
if (hasObject1(objectId)) {
return true;
}
for (final ObjectDatabase alt : getAlternates()) {
if (alt.hasObjectImpl1(objectId)) {
return true;
}
}
return tryAgain1() && hasObject1(objectId);
}
private final boolean hasObjectImpl2(final String objectId) {
if (hasObject2(objectId)) {
return true;
}
for (final ObjectDatabase alt : getAlternates()) {
if (alt.hasObjectImpl2(objectId)) {
return true;
}
}
return false;
}
/**
* Fast half of {@link #hasObject(AnyObjectId)}.
*
* @param objectId
* identity of the object to test for existence of.
* @return true if the specified object is stored in this database.
*/
protected abstract boolean hasObject1(AnyObjectId objectId);
/**
* Slow half of {@link #hasObject(AnyObjectId)}.
*
* @param objectName
* identity of the object to test for existence of.
* @return true if the specified object is stored in this database.
*/
protected boolean hasObject2(String objectName) {
// Assume the search took place during hasObject1.
return false;
}
/**
* Open an object from this database.
*
* Alternates (if present) are searched automatically.
*
* @param curs
* temporary working space associated with the calling thread.
* @param objectId
* identity of the object to open.
* @return a {@link ObjectLoader} for accessing the data of the named
* object, or null if the object does not exist.
* @throws IOException
*/
public final ObjectLoader openObject(final WindowCursor curs,
final AnyObjectId objectId) throws IOException {
ObjectLoader ldr;
ldr = openObjectImpl1(curs, objectId);
if (ldr != null) {
return ldr;
}
ldr = openObjectImpl2(curs, objectId.name(), objectId);
if (ldr != null) {
return ldr;
}
return null;
}
private ObjectLoader openObjectImpl1(final WindowCursor curs,
final AnyObjectId objectId) throws IOException {
ObjectLoader ldr;
ldr = openObject1(curs, objectId);
if (ldr != null) {
return ldr;
}
for (final ObjectDatabase alt : getAlternates()) {
ldr = alt.openObjectImpl1(curs, objectId);
if (ldr != null) {
return ldr;
}
}
if (tryAgain1()) {
ldr = openObject1(curs, objectId);
if (ldr != null) {
return ldr;
}
}
return null;
}
private ObjectLoader openObjectImpl2(final WindowCursor curs,
final String objectName, final AnyObjectId objectId)
throws IOException {
ObjectLoader ldr;
ldr = openObject2(curs, objectName, objectId);
if (ldr != null) {
return ldr;
}
for (final ObjectDatabase alt : getAlternates()) {
ldr = alt.openObjectImpl2(curs, objectName, objectId);
if (ldr != null) {
return ldr;
}
}
return null;
}
/**
* Fast half of {@link #openObject(WindowCursor, AnyObjectId)}.
*
* @param curs
* temporary working space associated with the calling thread.
* @param objectId
* identity of the object to open.
* @return a {@link ObjectLoader} for accessing the data of the named
* object, or null if the object does not exist.
* @throws IOException
*/
protected abstract ObjectLoader openObject1(WindowCursor curs,
AnyObjectId objectId) throws IOException;
/**
* Slow half of {@link #openObject(WindowCursor, AnyObjectId)}.
*
* @param curs
* temporary working space associated with the calling thread.
* @param objectName
* name of the object to open.
* @param objectId
* identity of the object to open.
* @return a {@link ObjectLoader} for accessing the data of the named
* object, or null if the object does not exist.
* @throws IOException
*/
protected ObjectLoader openObject2(WindowCursor curs, String objectName,
AnyObjectId objectId) throws IOException {
// Assume the search took place during openObject1.
return null;
}
/**
* Open the object from all packs containing it.
*
* If any alternates are present, their packs are also considered.
*
* @param out
* result collection of loaders for this object, filled with
* loaders from all packs containing specified object
* @param curs
* temporary working space associated with the calling thread.
* @param objectId
* id of object to search for
* @throws IOException
*/
final void openObjectInAllPacks(final Collection
* This method is invoked by {@link #getAlternates()} if the alternate list
* has not yet been populated, or if {@link #closeAlternates()} has been
* called on this instance and the alternate list is needed again.
*
* If the alternate array is empty, implementors should consider using the
* constant {@link #NO_ALTERNATES}.
*
* @return the alternate list for this database.
* @throws IOException
* the alternate list could not be accessed. The empty alternate
* array {@link #NO_ALTERNATES} will be assumed by the caller.
*/
protected ObjectDatabase[] loadAlternates() throws IOException {
return NO_ALTERNATES;
}
/**
* Close the list of alternates returned by {@link #loadAlternates()}.
*
* @param alt
* the alternate list, from {@link #loadAlternates()}.
*/
protected void closeAlternates(ObjectDatabase[] alt) {
for (final ObjectDatabase d : alt) {
d.close();
}
}
/**
* Create a new cached database instance over this database. This instance might
* optimize queries by caching some information about database. So some modifications
* done after instance creation might fail to be noticed.
*
* @return new cached database instance
* @see CachedObjectDatabase
*/
public ObjectDatabase newCachedDatabase() {
return new CachedObjectDatabase(this);
}
}