/*******************************************************************************
* Copyright (c) 2004, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.internal.localstore;
import java.io.*;
import java.util.Arrays;
import java.util.Comparator;
import org.eclipse.core.internal.utils.UniversalUniqueIdentifier;
import org.eclipse.core.runtime.IPath;
public class HistoryBucket extends Bucket {
/**
* A entry in the bucket index. Each entry has one path and a collection of states, which by
* their turn contain a (UUID, timestamp) pair.
* <p>
* This class is intended as a lightweight way of hiding the internal data structure. Objects of
* this class are supposed to be short-lived. No instances of this class are kept stored
* anywhere. The real stuff (the internal data structure) is.
* </p>
*/
public static final class HistoryEntry extends Bucket.Entry {
final static Comparator COMPARATOR= new Comparator() {
public int compare(Object o1, Object o2) {
byte[] state1= (byte[])o1;
byte[] state2= (byte[])o2;
return compareStates(state1, state2);
}
};
// the length of each component of the data array
private final static byte[][] EMPTY_DATA= new byte[0][];
// the length of a long in bytes
private final static int LONG_LENGTH= 8;
// the length of a UUID in bytes
private final static int UUID_LENGTH= UniversalUniqueIdentifier.BYTES_SIZE;
public final static int DATA_LENGTH= UUID_LENGTH + LONG_LENGTH;
/**
* The history states. The first array dimension is the number of states. The second
* dimension is an encoding of the {UUID,timestamp} pair for that entry.
*/
private byte[][] data;
/**
* Comparison logic for states in byte[] form.
*
* @see Comparator#compare(java.lang.Object, java.lang.Object)
*/
private static int compareStates(byte[] state1, byte[] state2) {
long timestamp1= getTimestamp(state1);
long timestamp2= getTimestamp(state2);
if (timestamp1 == timestamp2)
return -UniversalUniqueIdentifier.compareTime(state1, state2);
return timestamp1 < timestamp2 ? +1 : -1;
}
/**
* Returns the byte array representation of a (UUID, timestamp) pair.
*/
private static byte[] getState(UniversalUniqueIdentifier uuid, long timestamp) {
byte[] uuidBytes= uuid.toBytes();
byte[] state= new byte[DATA_LENGTH];
System.arraycopy(uuidBytes, 0, state, 0, uuidBytes.length);
for (int j= 0; j < LONG_LENGTH; j++) {
state[UUID_LENGTH + j]= (byte)(0xFF & timestamp);
timestamp>>>= 8;
}
return state;
}
private static long getTimestamp(byte[] state) {
long timestamp= 0;
for (int j= 0; j < LONG_LENGTH; j++)
timestamp+= (state[UUID_LENGTH + j] & 0xFFL) << j * 8;
return timestamp;
}
/**
* Inserts the given item into the given array at the right position. Returns the resulting
* array. Returns null if the item already exists.
*/
private static byte[][] insert(byte[][] existing, byte[] toAdd) {
// look for the right spot where to insert the new guy
int index= search(existing, toAdd);
if (index >= 0)
// already there - nothing else to be done
return null;
// not found - insert
int insertPosition= -index - 1;
byte[][] newValue= new byte[existing.length + 1][];
if (insertPosition > 0)
System.arraycopy(existing, 0, newValue, 0, insertPosition);
newValue[insertPosition]= toAdd;
if (insertPosition < existing.length)
System.arraycopy(existing, insertPosition, newValue, insertPosition + 1, existing.length - insertPosition);
return newValue;
}
/**
* Merges two entries (are always sorted). Duplicates are discarded.
*/
private static byte[][] merge(byte[][] base, byte[][] additions) {
int additionPointer= 0;
int basePointer= 0;
int added= 0;
byte[][] result= new byte[base.length + additions.length][];
while (basePointer < base.length && additionPointer < additions.length) {
int comparison= compareStates(base[basePointer], additions[additionPointer]);
if (comparison == 0) {
result[added++]= base[basePointer++];
// duplicate, ignore
additionPointer++;
} else if (comparison < 0)
result[added++]= base[basePointer++];
else
result[added++]= additions[additionPointer++];
}
// copy the remaining states from either additions or base arrays
byte[][] remaining= basePointer == base.length ? additions : base;
int remainingPointer= basePointer == base.length ? additionPointer : basePointer;
int remainingCount= remaining.length - remainingPointer;
System.arraycopy(remaining, remainingPointer, result, added, remainingCount);
added+= remainingCount;
if (added == base.length + additions.length)
// no collisions
return result;
// there were collisions, need to compact
byte[][] finalResult= new byte[added][];
System.arraycopy(result, 0, finalResult, 0, finalResult.length);
return finalResult;
}
private static int search(byte[][] existing, byte[] element) {
return Arrays.binarySearch(existing, element, COMPARATOR);
}
public HistoryEntry(IPath path, byte[][] data) {
super(path);
this.data= data;
}
public HistoryEntry(IPath path, HistoryEntry base) {
super(path);
this.data= new byte[base.data.length][];
System.arraycopy(base.data, 0, this.data, 0, this.data.length);
}
/**
* Compacts the data array removing any null slots. If non-null slots are found, the entry
* is marked for removal.
*/
private void compact() {
if (!isDirty())
return;
int occurrences= 0;
for (int i= 0; i < data.length; i++)
if (data[i] != null)
data[occurrences++]= data[i];
if (occurrences == data.length)
// no states deleted
return;
if (occurrences == 0) {
// no states remaining
data= EMPTY_DATA;
delete();
return;
}
byte[][] result= new byte[occurrences][];
System.arraycopy(data, 0, result, 0, occurrences);
data= result;
}
public void deleteOccurrence(int i) {
markDirty();
data[i]= null;
}
byte[][] getData() {
return data;
}
public int getOccurrences() {
return data.length;
}
public long getTimestamp(int i) {
return getTimestamp(data[i]);
}
public UniversalUniqueIdentifier getUUID(int i) {
return new UniversalUniqueIdentifier(data[i]);
}
public Object getValue() {
return data;
}
public boolean isEmpty() {
return data.length == 0;
}
public void visited() {
compact();
}
}
/**
* Version number for the current implementation file's format.
* <p>
* Version 2 (3.1 M5):
*
* <pre>
* FILE ::= VERSION_ID ENTRY+
* ENTRY ::= PATH STATE_COUNT STATE+
* PATH ::= string (does not include project name)
* STATE_COUNT ::= int
* STATE ::= UUID LAST_MODIFIED
* UUID ::= byte[16]
* LAST_MODIFIED ::= byte[8]
* </pre>
*
* </p>
* <p>
* Version 1 (3.1 M4):
*
* <pre>
* FILE ::= VERSION_ID ENTRY+
* ENTRY ::= PATH STATE_COUNT STATE+
* PATH ::= string
* STATE_COUNT ::= int
* STATE ::= UUID LAST_MODIFIED
* UUID ::= byte[16]
* LAST_MODIFIED ::= byte[8]
* </pre>
*
* </p>
*/
public final static byte VERSION= 2;
public HistoryBucket() {
super();
}
public void addBlob(IPath path, UniversalUniqueIdentifier uuid, long lastModified) {
byte[] state= HistoryEntry.getState(uuid, lastModified);
String pathAsString= path.toString();
byte[][] existing= (byte[][])getEntryValue(pathAsString);
if (existing == null) {
setEntryValue(pathAsString, new byte[][] { state });
return;
}
byte[][] newValue= HistoryEntry.insert(existing, state);
if (newValue == null)
return;
setEntryValue(pathAsString, newValue);
}
public void addBlobs(HistoryEntry fileEntry) {
IPath path= fileEntry.getPath();
byte[][] additions= fileEntry.getData();
String pathAsString= path.toString();
byte[][] existing= (byte[][])getEntryValue(pathAsString);
if (existing == null) {
setEntryValue(pathAsString, additions);
return;
}
setEntryValue(pathAsString, HistoryEntry.merge(existing, additions));
}
protected Bucket.Entry createEntry(IPath path, Object value) {
return new HistoryEntry(path, (byte[][])value);
}
public HistoryEntry getEntry(IPath path) {
String pathAsString= path.toString();
byte[][] existing= (byte[][])getEntryValue(pathAsString);
if (existing == null)
return null;
return new HistoryEntry(path, existing);
}
protected String getIndexFileName() {
return "history.index"; //$NON-NLS-1$
}
protected byte getVersion() {
return VERSION;
}
protected String getVersionFileName() {
return "history.version"; //$NON-NLS-1$
}
protected Object readEntryValue(DataInputStream source) throws IOException {
int length= source.readUnsignedShort();
byte[][] uuids= new byte[length][HistoryEntry.DATA_LENGTH];
for (int j= 0; j < uuids.length; j++)
source.read(uuids[j]);
return uuids;
}
protected void writeEntryValue(DataOutputStream destination, Object entryValue) throws IOException {
byte[][] uuids= (byte[][])entryValue;
destination.writeShort(uuids.length);
for (int j= 0; j < uuids.length; j++)
destination.write(uuids[j]);
}
}