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