public void Add(HgRevlogEntry revlogEntry)
{
var node = new HgRevlogGraphNode(revlogEntry.NodeID, revlogEntry.Revision);
//
// We only link back to Root when both parents are Null
if(revlogEntry.FirstParentRevisionNodeID == HgNodeID.Null && revlogEntry.SecondParentRevisionNodeID == HgNodeID.Null)
{
node.FirstParent = Root;
Root.Children.Add(node);
} // if
else
{
node.FirstParent = nodes[revlogEntry.FirstParentRevisionNodeID.Long]; // First parent is always there
node.SecondParenet =
revlogEntry.SecondParentRevisionNodeID == HgNodeID.Null ?
null :
nodes[revlogEntry.SecondParentRevisionNodeID.Long];
node.FirstParent.Children.Add(node);
if(node.SecondParenet != null)
node.SecondParenet.Children.Add(node);
} // else
nodes[node.NodeID.Long] = node;
}
public HgFile(HgPath path, HgRevlogEntry entry, byte[] data, HgFileCopyInfo copyInfo)
{
Path = path;
Entry = entry;
Data = data;
CopyInfo = copyInfo;
}
internal virtual void Add(HgRevlogEntry hgRevlogEntry)
{
entries.Add(hgRevlogEntry);
nodeCache[hgRevlogEntry.NodeID] = hgRevlogEntry.Revision;
//nodeCache[hgRevlogEntry.NodeID] = hgRevlogEntry;
//revisionCache[hgRevlogEntry.Revision] = hgRevlogEntry;
}
private HgRevlogEntry GetRevlogEntry(HgRevlogEntry revlogEntry)
{
var revlogEntryData = standinRevlogReader.ReadRevlogEntry(revlogEntry.NodeID);
var data = revlogEntryData.Data;
HgFileCopyInfo.ExtractFileCopyInfo(ref data);
//
// Apparently, entries in standins end with \n, so we explicitly limit to 40 bytes
HgNodeID nodeID;
if(HgNodeID.TryParse(Encoding.ASCII.GetString(data, 0, 40), out nodeID))
{
var lfPath = Path.Combine(storeBasePath, @"..\largefiles", nodeID.Long);
var lf = new FileInfo(lfPath);
if(lf.Exists)
{
revlogEntry = new HgRevlogEntry(revlogEntry.Revision, revlogEntry.NodeID, revlogEntry.Offset,
revlogEntry.Flags, revlogEntry.CompressedLength, (uint)lf.Length, revlogEntry.BaseRevision, revlogEntry.LinkRevision,
revlogEntry.FirstParentRevision, revlogEntry.FirstParentRevisionNodeID, revlogEntry.SecondParentRevision, revlogEntry.SecondParentRevisionNodeID);
} // if
} // if
return revlogEntry;
}
public HgRevlogEntryData(HgRevlogEntry entry, byte[] data)
{
Entry = entry;
Data = data;
}
public void WriteRevlogEntryDataRaw(HgNodeID revlogEntryNodeID, uint linkRevision, HgNodeID firstParentNodeID, HgNodeID secondParentNodeID, byte[] data,
ref ulong offset, uint baseRevision, uint uncompressedLength, out uint compressedLength, IBinaryWriter indexBinaryWriter, IBinaryWriter dataBinaryWriter)
{
if(!File.Exists(revlog.IndexPath))
{
//
// We need to decide whether we want inline data initially
// No, it's not you who decides.
// revlog.InlineData = data.Length < MaxInlineFileSize;
WriteRevlog();
} // if
var tip = revlog.Entries.Count > 0 ? revlog.Entries[revlog.Entries.Count - 1] : null;
if(tip != null && baseRevision < tip.BaseRevision)
{
throw new Exception("invalid base revision");
} // if
byte[] revlogEntryData = data;
/*ulong offset = 0;
uint baseRevision = 0;*/
if(revlog.GetEntry(revlogEntryNodeID) != null)
{
compressedLength = 0;
return;
} // if
var revlogEntryDataTuple = GetPotentiallyCompressedData(revlogEntryData, 0, revlogEntryData.Length);
//var uncompressedLength = (uint)data.Length;
compressedLength = (uint)(revlogEntryDataTuple.Item2.Length + (revlogEntryDataTuple.Item1 == null ? 0 : 1));
var firstParentRevlogEntry = revlog.GetEntry(firstParentNodeID);
var secondParentRevlogEntry = revlog.GetEntry(secondParentNodeID);
var firstParentRevision = firstParentRevlogEntry == null ? uint.MaxValue : firstParentRevlogEntry.Revision;
var secondParentRevision = secondParentRevlogEntry == null ? uint.MaxValue : secondParentRevlogEntry.Revision;
var revlogEntry = new HgRevlogEntry((uint)revlog.Entries.Count, revlogEntryNodeID, offset, 0,
compressedLength, uncompressedLength, baseRevision, linkRevision,
firstParentRevision, firstParentNodeID, secondParentRevision, secondParentNodeID);
revlog.Add(revlogEntry);
log.Debug("writing revlog entry {0} for changeset r{1}", revlogEntryNodeID.Short, linkRevision);
/*using(var fileStream = fileSystem.OpenWrite(revlog.IndexPath))
{
fileStream.Seek(fileStream.Length, SeekOrigin.Begin);
using(var binaryWriter = new BigEndianBinaryWriter(fileStream))
{*/
if(offset >= 0 && revlogEntry.Revision > 0)
{
var offsetBuffer = new byte[6];
Buffer.BlockCopy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((long)offset)), 2, offsetBuffer, 0, 6);
indexBinaryWriter.Write(offsetBuffer);
} // if
indexBinaryWriter.Write(revlogEntry.Flags);
indexBinaryWriter.Write(revlogEntry.CompressedLength);
indexBinaryWriter.Write(revlogEntry.UncompressedLength);
indexBinaryWriter.Write(revlogEntry.BaseRevision);
indexBinaryWriter.Write(revlogEntry.LinkRevision);
indexBinaryWriter.Write(revlogEntry.FirstParentRevision);
indexBinaryWriter.Write(revlogEntry.SecondParentRevision);
//
// Writing NodeID (20 bytes) and 12 more bytes (see HgRevlogReader)
indexBinaryWriter.Write(revlogEntry.NodeID.NodeID);
indexBinaryWriter.Write(new byte[12]);
if(revlog.InlineData)
{
if(revlogEntryDataTuple.Item1 != null)
indexBinaryWriter.Write(revlogEntryDataTuple.Item1.Value);
indexBinaryWriter.Write(revlogEntryDataTuple.Item2);
} // if
/* } // using
} // using
if(!revlog.InlineData && uncompressedLength > 0)
{
using(var fileStream = fileSystem.OpenOrCreateWrite(revlog.DataPath))
{
fileStream.Seek(fileStream.Length, SeekOrigin.Begin);
using(var binaryWriter = new BigEndianBinaryWriter(fileStream))*/
else
{
if(revlogEntryDataTuple.Item1 != null)
dataBinaryWriter.Write(revlogEntryDataTuple.Item1.Value);
dataBinaryWriter.Write(revlogEntryDataTuple.Item2);
/*} // using
} // using*/
} // if
offset += compressedLength;
}
internal override void Add(HgRevlogEntry hgRevlogEntry)
{
standinRevlog.Add(hgRevlogEntry);
}
