58 */
59 class PackageReader extends BandStructure {
60 Package pkg;
61 byte[] bytes;
62 LimitedBuffer in;
63 Package.Version packageVersion;
64
65 PackageReader(Package pkg, InputStream in) throws IOException {
66 this.pkg = pkg;
67 this.in = new LimitedBuffer(in);
68 }
69
70 /** A buffered input stream which is careful not to
71 * read its underlying stream ahead of a given mark,
72 * called the 'readLimit'. This property declares
73 * the maximum number of characters that future reads
74 * can consume from the underlying stream.
75 */
76 static
77 class LimitedBuffer extends BufferedInputStream {
78 static final InputStream NULL_STREAM = InputStream.nullInputStream();
79
80 long served; // total number of charburgers served
81 int servedPos; // ...as of this value of super.pos
82 long limit; // current declared limit
83 long buffered;
84 public boolean atLimit() {
85 boolean z = (getBytesServed() == limit);
86 assert(!z || limit == buffered);
87 return z;
88 }
89 public long getBytesServed() {
90 return served + (pos - servedPos);
91 }
92 public void setReadLimit(long newLimit) {
93 if (newLimit == -1)
94 limit = -1;
95 else
96 limit = getBytesServed() + newLimit;
97 }
98 public long getReadLimit() {
99 if (limit == -1)
108 }
109 served += (pos - servedPos);
110 int ch = super.read();
111 servedPos = pos;
112 if (ch >= 0) served += 1;
113 assert(served <= limit || limit == -1);
114 return ch;
115 }
116 public int read(byte b[], int off, int len) throws IOException {
117 served += (pos - servedPos);
118 int nr = super.read(b, off, len);
119 servedPos = pos;
120 if (nr >= 0) served += nr;
121 //assert(served <= limit || limit == -1);
122 return nr;
123 }
124 public long skip(long n) throws IOException {
125 throw new RuntimeException("no skipping");
126 }
127 LimitedBuffer(InputStream originalIn) {
128 super(NULL_STREAM, 1<<14);
129 servedPos = pos;
130 super.in = new FilterInputStream(originalIn) {
131 public int read() throws IOException {
132 if (buffered == limit)
133 return -1;
134 ++buffered;
135 return super.read();
136 }
137 public int read(byte b[], int off, int len) throws IOException {
138 if (buffered == limit)
139 return -1;
140 if (limit != -1) {
141 long remaining = limit - buffered;
142 if (len > remaining)
143 len = (int)remaining;
144 }
145 int nr = super.read(b, off, len);
146 if (nr >= 0) buffered += nr;
147 return nr;
148 }
|
58 */
59 class PackageReader extends BandStructure {
60 Package pkg;
61 byte[] bytes;
62 LimitedBuffer in;
63 Package.Version packageVersion;
64
65 PackageReader(Package pkg, InputStream in) throws IOException {
66 this.pkg = pkg;
67 this.in = new LimitedBuffer(in);
68 }
69
70 /** A buffered input stream which is careful not to
71 * read its underlying stream ahead of a given mark,
72 * called the 'readLimit'. This property declares
73 * the maximum number of characters that future reads
74 * can consume from the underlying stream.
75 */
76 static
77 class LimitedBuffer extends BufferedInputStream {
78 long served; // total number of charburgers served
79 int servedPos; // ...as of this value of super.pos
80 long limit; // current declared limit
81 long buffered;
82 public boolean atLimit() {
83 boolean z = (getBytesServed() == limit);
84 assert(!z || limit == buffered);
85 return z;
86 }
87 public long getBytesServed() {
88 return served + (pos - servedPos);
89 }
90 public void setReadLimit(long newLimit) {
91 if (newLimit == -1)
92 limit = -1;
93 else
94 limit = getBytesServed() + newLimit;
95 }
96 public long getReadLimit() {
97 if (limit == -1)
106 }
107 served += (pos - servedPos);
108 int ch = super.read();
109 servedPos = pos;
110 if (ch >= 0) served += 1;
111 assert(served <= limit || limit == -1);
112 return ch;
113 }
114 public int read(byte b[], int off, int len) throws IOException {
115 served += (pos - servedPos);
116 int nr = super.read(b, off, len);
117 servedPos = pos;
118 if (nr >= 0) served += nr;
119 //assert(served <= limit || limit == -1);
120 return nr;
121 }
122 public long skip(long n) throws IOException {
123 throw new RuntimeException("no skipping");
124 }
125 LimitedBuffer(InputStream originalIn) {
126 super(InputStream.nullInputStream(), 1<<14);
127 servedPos = pos;
128 super.in = new FilterInputStream(originalIn) {
129 public int read() throws IOException {
130 if (buffered == limit)
131 return -1;
132 ++buffered;
133 return super.read();
134 }
135 public int read(byte b[], int off, int len) throws IOException {
136 if (buffered == limit)
137 return -1;
138 if (limit != -1) {
139 long remaining = limit - buffered;
140 if (len > remaining)
141 len = (int)remaining;
142 }
143 int nr = super.read(b, off, len);
144 if (nr >= 0) buffered += nr;
145 return nr;
146 }
|