org.spearce.jgit/src/org/spearce/jgit/lib/PackedObjectReader.java

   1 package org.spearce.jgit.lib;
   2
   3 import java.io.BufferedInputStream;
   4 import java.io.IOException;
   5 import java.io.InputStream;
   6 import java.util.zip.DataFormatException;
   7 import java.util.zip.Inflater;
   8
   9 public class PackedObjectReader extends ObjectReader
  10 {
  11     private final PackReader pack;
  12
  13     private final long dataOffset;
  14
  15     private final ObjectId deltaBase;
  16
  17     private String objectType;
  18
  19     private long objectSize;
  20
  21     PackedObjectReader(
  22         final PackReader pr,
  23         final String type,
  24         final long size,
  25         final long offset,
  26         final ObjectId base)
  27     {
  28         pack = pr;
  29         dataOffset = offset;
  30         deltaBase = base;
  31         if (base != null)
  32         {
  33             objectSize = -1;
  34         }
  35         else
  36         {
  37             objectSize = size;
  38             objectType = type;
  39         }
  40     }
  41
  42     public void setId(final ObjectId id)
  43     {
  44         super.setId(id);
  45     }
  46
  47     public String getType() throws IOException
  48     {
  49         if (objectType == null && deltaBase != null)
  50         {
  51             objectType = baseReader().getType();
  52         }
  53         return objectType;
  54     }
  55
  56     public long getSize() throws IOException
  57     {
  58         if (objectSize == -1 && deltaBase != null)
  59         {
  60             final PatchDeltaStream p;
  61             p = new PatchDeltaStream(packStream(), null);
  62             objectSize = p.getResultLength();
  63             p.close();
  64         }
  65         return objectSize;
  66     }
  67
  68     public ObjectId getDeltaBaseId()
  69     {
  70         return deltaBase;
  71     }
  72
  73     public long getDataOffset()
  74     {
  75         return dataOffset;
  76     }
  77
  78     public InputStream getInputStream() throws IOException
  79     {
  80         if (deltaBase != null)
  81         {
  82             final ObjectReader b = baseReader();
  83             final PatchDeltaStream p = new PatchDeltaStream(packStream(), b);
  84             if (objectSize == -1)
  85             {
  86                 objectSize = p.getResultLength();
  87             }
  88             if (objectType == null)
  89             {
  90                 objectType = b.getType();
  91             }
  92             return p;
  93         }
  94         return packStream();
  95     }
  96
  97     public void close() throws IOException
  98     {
  99     }
 100
 101     private ObjectReader baseReader() throws IOException
 102     {
 103         final ObjectReader or = pack.resolveBase(getDeltaBaseId());
 104         if (or == null)
 105         {
 106             throw new CorruptObjectException(
 107                 deltaBase,
 108                 "is a delta base for another object but is missing.");
 109         }
 110         return or;
 111     }
 112
 113     private BufferedInputStream packStream()
 114     {
 115         return new BufferedInputStream(new PackStream());
 116     }
 117
 118     private class PackStream extends InputStream
 119     {
 120         private Inflater inf = new Inflater();
 121
 122         private byte[] in = new byte[2048];
 123
 124         private long offset = getDataOffset();
 125
 126         public int read() throws IOException
 127         {
 128             final byte[] singleByteBuffer = new byte[1];
 129             if (read(singleByteBuffer, 0, 1) == 1)
 130             {
 131                 return singleByteBuffer[0];
 132             }
 133             else
 134             {
 135                 return -1;
 136             }
 137         }
 138
 139         public int read(final byte[] b, final int off, final int len)
 140             throws IOException
 141         {
 142             if (inf.finished())
 143             {
 144                 return -1;
 145             }
 146
 147             if (inf.needsInput())
 148             {
 149                 final int n = pack.read(offset, in, 0, in.length);
 150                 inf.setInput(in, 0, n);
 151                 offset += n;
 152             }
 153
 154             try
 155             {
 156                 final int n = inf.inflate(b, off, len);
 157                 if (inf.finished())
 158                 {
 159                     pack.unread(inf.getRemaining());
 160                 }
 161                 return n;
 162             }
 163             catch (DataFormatException dfe)
 164             {
 165                 final IOException e = new IOException("Corrupt ZIP stream.");
 166                 e.initCause(dfe);
 167                 throw e;
 168             }
 169         }
 170
 171         public void close()
 172         {
 173             if (inf != null)
 174             {
 175                 inf.end();
 176                 inf = null;
 177                 in = null;
 178             }
 179         }
 180     }
 181 }