private InMemoryNoteBucket Parse()
{
InMemoryNoteBucket r = ParseTree();
r.nonNotes = firstNonNote;
return(r);
}
/// <summary>Construct a new note map from an existing note bucket.</summary>
/// <remarks>Construct a new note map from an existing note bucket.</remarks>
/// <param name="root">the root bucket of this note map</param>
/// <param name="reader">
/// reader to scan the note branch with. This reader may be
/// retained by the NoteMap for the life of the map in order to
/// support lazy loading of entries.
/// </param>
/// <returns>the note map built from the note bucket</returns>
internal static NGit.Notes.NoteMap NewMap(InMemoryNoteBucket root, ObjectReader reader
)
{
NGit.Notes.NoteMap map = new NGit.Notes.NoteMap(reader);
map.root = root;
return(map);
}
/// <exception cref="System.IO.IOException"></exception>
internal InMemoryNoteBucket Load(AnyObjectId prefix, ObjectReader or)
{
AbbreviatedObjectId p = prefix.Abbreviate(this._enclosing.prefixLen + 2);
InMemoryNoteBucket self = NoteParser.Parse(p, this.treeId, or);
this._enclosing.table[this._enclosing.Cell(prefix)] = self;
return(self);
}
/// <summary>Attach (or remove) a note on an object.</summary>
/// <remarks>
/// Attach (or remove) a note on an object.
/// If no note exists, a new note is stored. If a note already exists for the
/// given object, it is replaced (or removed).
/// This method only updates the map in memory.
/// If the caller wants to attach a UTF-8 encoded string message to an
/// object,
/// <see cref="Set(NGit.AnyObjectId, string, NGit.ObjectInserter)">Set(NGit.AnyObjectId, string, NGit.ObjectInserter)
/// </see>
/// is a convenient
/// way to encode and update a note in one step.
/// </remarks>
/// <param name="noteOn">
/// the object to attach the note to. This same ObjectId can later
/// be used as an argument to
/// <see cref="Get(NGit.AnyObjectId)">Get(NGit.AnyObjectId)</see>
/// or
/// <see cref="GetCachedBytes(NGit.AnyObjectId, int)">GetCachedBytes(NGit.AnyObjectId, int)
/// </see>
/// to read back the
/// <code>noteData</code>
/// .
/// </param>
/// <param name="noteData">
/// data to associate with the note. This must be the ObjectId of
/// a blob that already exists in the repository. If null the note
/// will be deleted, if present.
/// </param>
/// <exception cref="System.IO.IOException">a portion of the note space is not accessible.
/// </exception>
public virtual void Set(AnyObjectId noteOn, ObjectId noteData)
{
InMemoryNoteBucket newRoot = root.Set(noteOn, noteData, reader);
if (newRoot == null)
{
newRoot = new LeafBucket(0);
newRoot.nonNotes = root.nonNotes;
}
root = newRoot;
}
private FanoutBucket AsFanout(InMemoryNoteBucket bucket)
{
if (bucket == null)
{
return(EMPTY_FANOUT);
}
if (bucket is FanoutBucket)
{
return((FanoutBucket)bucket);
}
return(((LeafBucket)bucket).Split());
}
private static InMemoryNoteBucket AddIfNotNull(InMemoryNoteBucket result, Note note
)
{
if (note != null)
{
return(result.Append(note));
}
else
{
return(result);
}
}
/// <summary>Performs the merge.</summary>
/// <remarks>Performs the merge.</remarks>
/// <param name="base">base version of the note tree</param>
/// <param name="ours">ours version of the note tree</param>
/// <param name="theirs">theirs version of the note tree</param>
/// <returns>merge result as a new NoteMap</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
public virtual NoteMap Merge(NoteMap @base, NoteMap ours, NoteMap theirs)
{
try
{
InMemoryNoteBucket mergedBucket = Merge(0, @base.GetRoot(), ours.GetRoot(), theirs
.GetRoot());
inserter.Flush();
return(NoteMap.NewMap(mergedBucket, reader));
}
finally
{
reader.Release();
inserter.Release();
}
}
/// <summary>
/// This method is called only when it is known that there is some difference
/// between base, ours and theirs.
/// </summary>
/// <remarks>
/// This method is called only when it is known that there is some difference
/// between base, ours and theirs.
/// </remarks>
/// <param name="treeDepth"></param>
/// <param name="base"></param>
/// <param name="ours"></param>
/// <param name="theirs"></param>
/// <returns>merge result as an InMemoryBucket</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
private InMemoryNoteBucket Merge(int treeDepth, InMemoryNoteBucket @base, InMemoryNoteBucket
ours, InMemoryNoteBucket theirs)
{
InMemoryNoteBucket result;
if (@base is FanoutBucket || ours is FanoutBucket || theirs is FanoutBucket)
{
result = MergeFanoutBucket(treeDepth, AsFanout(@base), AsFanout(ours), AsFanout(theirs
));
}
else
{
result = MergeLeafBucket(treeDepth, (LeafBucket)@base, (LeafBucket)ours, (LeafBucket
)theirs);
}
result.nonNotes = MergeNonNotes(NonNotes(@base), NonNotes(ours), NonNotes(theirs)
);
return(result);
}
internal override InMemoryNoteBucket Append(Note note)
{
int cell = Cell(note);
InMemoryNoteBucket b = (InMemoryNoteBucket)table[cell];
if (b == null)
{
LeafBucket n = new LeafBucket(prefixLen + 2);
table[cell] = n.Append(note);
cnt++;
}
else
{
InMemoryNoteBucket n = b.Append(note);
if (n != b)
{
table[cell] = n;
}
}
return(this);
}
/// <exception cref="System.IO.IOException"></exception>
private InMemoryNoteBucket MergeFanoutBucket(int treeDepth, FanoutBucket @base, FanoutBucket
ours, FanoutBucket theirs)
{
FanoutBucket result = new FanoutBucket(treeDepth * 2);
// walking through entries of base, ours, theirs
for (int i = 0; i < 256; i++)
{
NoteBucket b = @base.GetBucket(i);
NoteBucket o = ours.GetBucket(i);
NoteBucket t = theirs.GetBucket(i);
if (Equals(o, t))
{
AddIfNotNull(result, i, o);
}
else
{
if (Equals(b, o))
{
AddIfNotNull(result, i, t);
}
else
{
if (Equals(b, t))
{
AddIfNotNull(result, i, o);
}
else
{
objectIdPrefix.SetByte(treeDepth, i);
InMemoryNoteBucket mergedBucket = Merge(treeDepth + 1, FanoutBucket.LoadIfLazy(b,
objectIdPrefix, reader), FanoutBucket.LoadIfLazy(o, objectIdPrefix, reader), FanoutBucket
.LoadIfLazy(t, objectIdPrefix, reader));
result.SetBucket(i, mergedBucket);
}
}
}
}
return(result.ContractIfTooSmall(objectIdPrefix, reader));
}
/// <summary>Attach (or remove) a note on an object.</summary>
/// <remarks>
/// Attach (or remove) a note on an object.
/// If no note exists, a new note is stored. If a note already exists for the
/// given object, it is replaced (or removed).
/// This method only updates the map in memory.
/// If the caller wants to attach a UTF-8 encoded string message to an
/// object,
/// <see cref="Set(NGit.AnyObjectId, string, NGit.ObjectInserter)">Set(NGit.AnyObjectId, string, NGit.ObjectInserter)
/// </see>
/// is a convenient
/// way to encode and update a note in one step.
/// </remarks>
/// <param name="noteOn">
/// the object to attach the note to. This same ObjectId can later
/// be used as an argument to
/// <see cref="Get(NGit.AnyObjectId)">Get(NGit.AnyObjectId)</see>
/// or
/// <see cref="GetCachedBytes(NGit.AnyObjectId, int)">GetCachedBytes(NGit.AnyObjectId, int)
/// </see>
/// to read back the
/// <code>noteData</code>
/// .
/// </param>
/// <param name="noteData">
/// data to associate with the note. This must be the ObjectId of
/// a blob that already exists in the repository. If null the note
/// will be deleted, if present.
/// </param>
/// <exception cref="System.IO.IOException">a portion of the note space is not accessible.
/// </exception>
public virtual void Set(AnyObjectId noteOn, ObjectId noteData)
{
InMemoryNoteBucket newRoot = root.Set(noteOn, noteData, reader);
if (newRoot == null)
{
newRoot = new LeafBucket(0);
newRoot.nonNotes = root.nonNotes;
}
root = newRoot;
}
private static NonNoteEntry NonNotes(InMemoryNoteBucket b)
{
return(b == null ? null : b.nonNotes);
}
private static InMemoryNoteBucket AddIfNotNull(InMemoryNoteBucket result, Note note
)
{
if (note != null)
{
return result.Append(note);
}
else
{
return result;
}
}
private static NonNoteEntry NonNotes(InMemoryNoteBucket b)
{
return b == null ? null : b.nonNotes;
}
private FanoutBucket AsFanout(InMemoryNoteBucket bucket)
{
if (bucket == null)
{
return EMPTY_FANOUT;
}
if (bucket is FanoutBucket)
{
return (FanoutBucket)bucket;
}
return ((LeafBucket)bucket).Split();
}
/// <summary>
/// This method is called only when it is known that there is some difference
/// between base, ours and theirs.
/// </summary>
/// <remarks>
/// This method is called only when it is known that there is some difference
/// between base, ours and theirs.
/// </remarks>
/// <param name="treeDepth"></param>
/// <param name="base"></param>
/// <param name="ours"></param>
/// <param name="theirs"></param>
/// <returns>merge result as an InMemoryBucket</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
private InMemoryNoteBucket Merge(int treeDepth, InMemoryNoteBucket @base, InMemoryNoteBucket
ours, InMemoryNoteBucket theirs)
{
InMemoryNoteBucket result;
if (@base is FanoutBucket || ours is FanoutBucket || theirs is FanoutBucket)
{
result = MergeFanoutBucket(treeDepth, AsFanout(@base), AsFanout(ours), AsFanout(theirs
));
}
else
{
result = MergeLeafBucket(treeDepth, (LeafBucket)@base, (LeafBucket)ours, (LeafBucket
)theirs);
}
result.nonNotes = MergeNonNotes(NonNotes(@base), NonNotes(ours), NonNotes(theirs)
);
return result;
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private void Load(ObjectId rootTree)
{
AbbreviatedObjectId none = AbbreviatedObjectId.FromString(string.Empty);
root = NoteParser.Parse(none, rootTree, reader);
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private void Load(ObjectId rootTree)
{
AbbreviatedObjectId none = AbbreviatedObjectId.FromString(string.Empty);
root = NoteParser.Parse(none, rootTree, reader);
}
internal virtual void SetBucket(int cell, InMemoryNoteBucket bucket)
{
table[cell] = bucket;
cnt++;
}
