public Interface ObjectReuseAsIs

Output a previously selected representation.

PackWriter invokes this method only if a representation previously given to it by selectObjectRepresentation was chosen for reuse into the output stream. The otp argument is an instance created by this reader's own newObjectToPack, and the representation data saved within it also originated from this reader.

Implementors must write the object header before copying the raw data to the output stream. The typical implementation is like:

MyToPack mtp = (MyToPack) otp;
byte[] raw;
if (validate)
	 raw = validate(mtp); // throw SORNAE here, if at all
else
	 raw = readFast(mtp);
out.writeHeader(mtp, mtp.inflatedSize);
out.write(raw);

Parameters

out:PackOutputStream

stream the object should be written to.

otp:ObjectToPack

the object's saved representation information.

validate:boolean

if true the representation must be validated and not be corrupt before being reused. If false, validation may be skipped as it will be performed elsewhere in the processing pipeline.

Exceptions

IOException:

the stream's write method threw an exception. Packing will abort.

StoredObjectRepresentationNotAvailableException:

the previously selected representation is no longer available. If thrown before out.writeHeader the pack writer will try to find another representation, and write that one instead. If throw after out.writeHeader, packing will abort.

Append an entire pack's contents onto the output stream.

The entire pack, excluding its header and trailing footer is sent.

Parameters

out:PackOutputStream

stream to append the pack onto.

pack:CachedPack

the cached pack to send.

Exceptions

IOException:

the pack cannot be read, or stream did not accept a write.

Obtain the available cached packs that match the bitmap and update the bitmap by removing the items that are in the CachedPack.

A cached pack has known starting points and may be sent entirely as-is, with almost no effort on the sender's part.

Parameters

needBitmap:BitmapIndex.BitmapBuilder

the bitmap that contains all of the objects the client wants.

Returns:Collection<CachedPack>

the available cached packs.

Exceptions

IOException:

the cached packs cannot be listed from the repository. Callers may choose to ignore this and continue as-if there were no cached packs.

Allocate a new PackWriter state structure for an object.

org.eclipse.jgit.internal.storage.pack.PackWriter allocates these objects to keep track of the per-object state, and how to load the objects efficiently into the generated stream. Implementers may subclass this type with additional object state, such as to remember what file and offset contains the object's pack encoded data.

Parameters

objectId:AnyObjectId

the id of the object that will be packed.

type:int

the Git type of the object that will be packed.

Returns:ObjectToPack

a new instance for this object.

Select the best object representation for a packer.

Implementations should iterate through all available representations of an object, and pass them in turn to the PackWriter though org.eclipse.jgit.internal.storage.pack.PackWriter#select(ObjectToPack, StoredObjectRepresentation) so the writer can select the most suitable representation to reuse into the output stream.

If the implementation returns CachedPack from getCachedPacksAndUpdate(BitmapBuilder) it must consider the representation of any object that is stored in any of the offered CachedPacks. PackWriter relies on this behavior to prune duplicate objects out of the pack stream when it selects a CachedPack and the object was also reached through the thin-pack enumeration.

The implementation may choose to consider multiple objects at once on concurrent threads, but must evaluate all representations of an object within the same thread.

Parameters

packer:PackWriter

the packer that will write the object in the near future.

monitor:ProgressMonitor

progress monitor, implementation should update the monitor once for each item in the iteration when selection is done.

objects:Iterable<ObjectToPack>

the objects that are being packed.

Exceptions

IOException:

the repository cannot be accessed. Packing will abort.

MissingObjectException:

there is no representation available for the object, as it is no longer in the repository. Packing will abort.

Write objects to the pack stream in roughly the order given. PackWriter invokes this method to write out one or more objects, in approximately the order specified by the iteration over the list. A simple implementation of this method would just iterate the list and output each object:

for (ObjectToPack obj : list)
  out.writeObject(obj)

Parameters

out:PackOutputStream

the stream to write each object to.

list:List<ObjectToPack>

the list of objects to write. Objects should be written in approximately this order. Implementors may resort the list elements in-place during writing if desired.

Exceptions

IOException:

the stream cannot be written to, or one or more required objects cannot be accessed from the object database.