private void SelectDeltaReuseForObject(ObjectToPack otp, IEnumerable <PackedObjectLoader> loaders)
{
PackedObjectLoader bestLoader = null;
ObjectId bestBase = null;
foreach (PackedObjectLoader loader in loaders)
{
ObjectId idBase = loader.DeltaBase;
if (idBase == null)
{
continue;
}
ObjectToPack otpBase = _objectsMap.Get(idBase);
if ((otpBase != null || (Thin && _edgeObjects.Get(idBase) != null)) && IsBetterDeltaReuseLoader(bestLoader, loader))
{
bestLoader = loader;
bestBase = (otpBase ?? idBase);
}
}
if (bestLoader == null)
{
return;
}
otp.SetReuseLoader(bestLoader);
otp.DeltaBaseId = bestBase;
}
private void WriteDeltaObjectReuse(ObjectToPack otp, PackedObjectLoader reuse)
{
if (DeltaBaseAsOffset && otp.DeltaBase != null)
{
WriteObjectHeader(Constants.OBJ_OFS_DELTA, reuse.RawSize);
ObjectToPack deltaBase = otp.DeltaBase;
long offsetDiff = otp.Offset - deltaBase.Offset;
int localPos = _buf.Length - 1;
_buf[localPos] = (byte)(offsetDiff & 0x7F);
while ((offsetDiff >>= 7) > 0)
{
_buf[--localPos] = (byte)(0x80 | (--offsetDiff & 0x7F));
}
_pos.Write(_buf, localPos, _buf.Length - localPos);
}
else
{
WriteObjectHeader(Constants.OBJ_REF_DELTA, reuse.RawSize);
otp.DeltaBaseId.copyRawTo(_buf, 0);
_pos.Write(_buf, 0, Constants.OBJECT_ID_LENGTH);
}
reuse.CopyRawData(_pos, _buf, _windowCursor);
}
/// <exception cref="System.IO.IOException"></exception>
/// <exception cref="NGit.Errors.StoredObjectRepresentationNotAvailableException"></exception>
public void CopyObjectAsIs(PackOutputStream @out, ObjectToPack otp, bool validate
)
{
LocalObjectToPack src = (LocalObjectToPack)otp;
src.pack.CopyAsIs(@out, src, validate, this);
}
private void WriteObject(ObjectToPack otp)
{
otp.MarkWantWrite();
if (otp.IsDeltaRepresentation)
{
ObjectToPack deltaBase = otp.DeltaBase;
Debug.Assert(deltaBase != null || Thin);
if (deltaBase != null && !deltaBase.IsWritten)
{
if (deltaBase.WantWrite)
{
otp.ClearDeltaBase();
otp.DisposeLoader();
}
else
{
WriteObject(deltaBase);
}
}
}
Debug.Assert(!otp.IsWritten);
_pos.resetCRC32();
otp.Offset = _pos.Length;
PackedObjectLoader reuse = Open(otp);
if (reuse != null)
{
try
{
if (otp.IsDeltaRepresentation)
{
WriteDeltaObjectReuse(otp, reuse);
}
else
{
WriteObjectHeader(otp.Type, reuse.Size);
reuse.CopyRawData(_pos, _buf, _windowCursor);
}
}
finally
{
reuse.endCopyRawData();
}
}
else if (otp.IsDeltaRepresentation)
{
throw new IOException("creating deltas is not implemented");
}
else
{
WriteWholeObjectDeflate(otp);
}
otp.CRC = _pos.getCRC32();
_writeMonitor.Update(1);
}
private static void SelectObjectReuseForObject(ObjectToPack otp, IEnumerable <PackedObjectLoader> loaders)
{
foreach (PackedObjectLoader loader in loaders)
{
if (!(loader is WholePackedObjectLoader))
{
continue;
}
otp.SetReuseLoader(loader);
return;
}
}
private void SearchForReuse(ICollection <PackedObjectLoader> reuseLoaders, ObjectToPack otp)
{
_db.OpenObjectInAllPacks(otp, reuseLoaders, _windowCursor);
if (ReuseDeltas)
{
SelectDeltaReuseForObject(otp, reuseLoaders);
}
if (ReuseObjects && !otp.HasReuseLoader)
{
SelectObjectReuseForObject(otp, reuseLoaders);
}
}
private void WriteWholeObjectDeflate(ObjectToPack otp)
{
ObjectLoader loader = _db.OpenObject(_windowCursor, otp);
byte[] data = loader.CachedBytes;
WriteObjectHeader(otp.Type, data.Length);
_deflater.Reset();
_deflater.SetInput(data, 0, data.Length);
_deflater.Finish();
do
{
int n = _deflater.Deflate(_buf, 0, _buf.Length);
if (n > 0)
{
_pos.Write(_buf, 0, n);
}
} while (!_deflater.IsFinished);
}
public override bool HasObject(ObjectToPack obj, StoredObjectRepresentation rep)
{
try
{
LocalObjectRepresentation local = (LocalObjectRepresentation)rep;
foreach (PackFile pack in GetPacks())
{
if (local.pack == pack)
{
return(true);
}
}
return(false);
}
catch (FileNotFoundException)
{
return(false);
}
}
/// <exception cref="NGit.Errors.StoredObjectRepresentationNotAvailableException"></exception>
private void BeginCopyAsIs(ObjectToPack otp)
{
lock (this)
{
if (++activeCopyRawData == 1 && activeWindows == 0)
{
try
{
DoOpen();
}
catch (IOException thisPackNotValid)
{
StoredObjectRepresentationNotAvailableException gone;
gone = new StoredObjectRepresentationNotAvailableException(otp);
Sharpen.Extensions.InitCause(gone, thisPackNotValid);
throw gone;
}
}
}
}
public void addObject(RevObject robject)
{
if (robject.has(RevFlag.UNINTERESTING))
{
_edgeObjects.Add(robject);
Thin = true;
return;
}
var otp = new ObjectToPack(robject, robject.Type);
try
{
_objectsLists[robject.Type].Add(otp);
}
catch (IndexOutOfRangeException)
{
throw new IncorrectObjectTypeException(robject, "COMMIT nor TREE nor BLOB nor TAG");
}
_objectsMap.Add(otp);
}
/// <exception cref="System.IO.IOException"></exception>
internal override void SelectObjectRepresentation(PackWriter packer, ObjectToPack
otp, WindowCursor curs)
{
ObjectDirectory.PackList pList = packList.Get();
for (; ;)
{
foreach (PackFile p in pList.packs)
{
try
{
LocalObjectRepresentation rep = p.Representation(curs, otp);
if (rep != null)
{
packer.Select(otp, rep);
}
}
catch (PackMismatchException)
{
// Pack was modified; refresh the entire pack list.
//
pList = ScanPacks(pList);
goto SEARCH_continue;
}
catch (IOException)
{
// Assume the pack is corrupted.
//
RemovePack(p);
}
}
goto SEARCH_break;
SEARCH_continue :;
}
SEARCH_break :;
foreach (FileObjectDatabase.AlternateHandle h in MyAlternates())
{
h.db.SelectObjectRepresentation(packer, otp, curs);
}
}
private PackedObjectLoader Open(ObjectToPack otp)
{
while (true)
{
PackedObjectLoader reuse = otp.UseLoader();
if (reuse == null)
{
return(null);
}
try
{
reuse.beginCopyRawData();
return(reuse);
}
catch (IOException)
{
otp.ClearDeltaBase();
SearchForReuse(new List <PackedObjectLoader>(), otp);
continue;
}
}
}
/// <summary>Construct an error for an object.</summary>
/// <remarks>Construct an error for an object.</remarks>
/// <param name="otp">the object whose current representation is no longer present.</param>
public StoredObjectRepresentationNotAvailableException(ObjectToPack otp)
{
}
/// <exception cref="System.IO.IOException"></exception>
internal override void SelectObjectRepresentation(PackWriter packer, ObjectToPack
otp, WindowCursor curs)
{
wrapped.SelectObjectRepresentation(packer, otp, curs);
}
/// <exception cref="System.IO.IOException"></exception>
internal abstract void SelectObjectRepresentation(PackWriter packer, ObjectToPack
otp, WindowCursor curs);
