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);