Class Patch

java.lang.Object
org.eclipse.jgit.patch.Patch

public class Patch extends Object
A parsed collection of FileHeaders from a unified diff patch file
  • Field Details

    • DIFF_GIT

      static final byte[] DIFF_GIT
    • DIFF_CC

      private static final byte[] DIFF_CC
    • DIFF_COMBINED

      private static final byte[] DIFF_COMBINED
    • BIN_HEADERS

      private static final byte[][] BIN_HEADERS
    • BIN_TRAILER

      private static final byte[] BIN_TRAILER
    • GIT_BINARY

      private static final byte[] GIT_BINARY
    • files

      private final List<FileHeader> files
      The files, in the order they were parsed out of the input.
    • errors

      private final List<FormatError> errors
      Formatting errors, if any were identified.
  • Constructor Details

    • Patch

      public Patch()
      Create an empty patch.
  • Method Details

    • addFile

      public void addFile(FileHeader fh)
      Add a single file to this patch.

      Typically files should be added by parsing the text through one of this class's parse methods.

      Parameters:
      fh - the header of the file.
    • getFiles

      public List<? extends FileHeader> getFiles()
      Get list of files described in the patch, in occurrence order.
      Returns:
      list of files described in the patch, in occurrence order.
    • addError

      public void addError(FormatError err)
      Add a formatting error to this patch script.
      Parameters:
      err - the error description.
    • getErrors

      public List<FormatError> getErrors()
      Get collection of formatting errors.
      Returns:
      collection of formatting errors, if any.
    • parse

      public void parse(InputStream is) throws IOException
      Parse a patch received from an InputStream.

      Multiple parse calls on the same instance will concatenate the patch data, but each parse input must start with a valid file header (don't split a single file across parse calls).

      Parameters:
      is - the stream to read the patch data from. The stream is read until EOF is reached.
      Throws:
      IOException - there was an error reading from the input stream.
    • readFully

      private static byte[] readFully(InputStream is) throws IOException
      Throws:
      IOException
    • parse

      public void parse(byte[] buf, int ptr, int end)
      Parse a patch stored in a byte[].

      Multiple parse calls on the same instance will concatenate the patch data, but each parse input must start with a valid file header (don't split a single file across parse calls).

      Parameters:
      buf - the buffer to parse.
      ptr - starting position to parse from.
      end - 1 past the last position to end parsing. The total length to be parsed is end - ptr.
    • parseFile

      private int parseFile(byte[] buf, int c, int end)
    • parseDiffGit

      private int parseDiffGit(byte[] buf, int start, int end)
    • parseDiffCombined

      private int parseDiffCombined(byte[] hdr, byte[] buf, int start, int end)
    • parseTraditionalPatch

      private int parseTraditionalPatch(byte[] buf, int start, int end)
    • skipFile

      private static int skipFile(byte[] buf, int ptr)
    • parseHunks

      private int parseHunks(FileHeader fh, int c, int end)
    • parseGitBinary

      private int parseGitBinary(FileHeader fh, int c, int end)
    • warn

      void warn(byte[] buf, int ptr, String msg)
    • error

      void error(byte[] buf, int ptr, String msg)
    • matchAny

      private static boolean matchAny(byte[] buf, int c, byte[][] srcs)