EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.iapi.services.io]

COVERAGE SUMMARY FOR SOURCE FILE [LimitInputStream.java]

nameclass, %method, %block, %line, %
LimitInputStream.java100% (1/1)88%  (7/8)89%  (133/149)87%  (41/47)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class LimitInputStream100% (1/1)88%  (7/8)89%  (133/149)87%  (41/47)
LimitInputStream (InputStream): void 100% (1/1)100% (7/7)100% (3/3)
available (): int 100% (1/1)48%  (11/23)50%  (4/8)
clearLimit (): int 100% (1/1)100% (11/11)100% (4/4)
read (): int 100% (1/1)100% (24/24)100% (8/8)
read (byte [], int, int): int 100% (1/1)100% (37/37)100% (10/10)
setInput (InputStream): void 0%   (0/1)0%   (0/4)0%   (0/2)
setLimit (int): void 100% (1/1)100% (7/7)100% (3/3)
skip (long): long 100% (1/1)100% (36/36)100% (9/9)

1/*
2 
3   Derby - Class org.apache.derby.iapi.services.io.LimitInputStream
4 
5   Copyright 1998, 2004 The Apache Software Foundation or its licensors, as applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19 */
20 
21package org.apache.derby.iapi.services.io;
22 
23import java.io.InputStream;
24import java.io.FilterInputStream;
25import java.io.IOException;
26 
27/**
28        An abstract InputStream that provides abstract methods to limit the range that
29        can be read from the stream.
30*/
31public class LimitInputStream extends FilterInputStream implements Limit {
32 
33        protected int remainingBytes;
34        protected boolean limitInPlace;
35 
36        /**
37                Construct a LimitInputStream and call the clearLimit() method.
38        */
39        public LimitInputStream(InputStream in) {
40                super(in);
41                clearLimit();
42        }
43 
44        public int read() throws IOException {
45 
46                if (!limitInPlace)
47                        return super.read();
48                
49                if (remainingBytes == 0)
50                        return -1; // end of file
51 
52                
53                int value = super.read();
54                if (value >= 0)
55                        remainingBytes--;
56                return value;
57 
58        }
59 
60        public int read(byte b[], int off, int len) throws IOException {
61 
62                if (!limitInPlace)
63                        return super.read(b, off, len);
64 
65 
66                if (remainingBytes == 0)
67                        return -1;
68 
69                if (remainingBytes < len) {
70                        len = remainingBytes; // end of file
71                }
72 
73                len = super.read(b, off, len);
74                if (len > 0)
75                        remainingBytes -= len;
76 
77                return len;
78        }
79 
80        public long skip(long count)  throws IOException {
81                if (!limitInPlace)
82                        return super.skip(count);
83 
84                if (remainingBytes == 0)
85                        return 0; // end of file
86 
87                if (remainingBytes < count)
88                        count = remainingBytes;
89 
90                count = super.skip(count);
91                remainingBytes -= count;
92                return count;
93        }
94 
95        public int available() throws IOException {
96 
97                if (!limitInPlace)
98                        return super.available();
99 
100                if (remainingBytes == 0)
101                        return 0; // end of file
102 
103                int actualLeft = super.available();
104 
105                if (remainingBytes < actualLeft)
106                        return remainingBytes;
107                
108 
109                return actualLeft;
110        }
111 
112 
113        /**
114                Set the limit of the stream that can be read. After this
115                call up to and including length bytes can be read from or skipped in
116                the stream. Any attempt to read more than length bytes will
117                result in an EOFException
118 
119                @exception IOException IOException from some underlying stream
120                @exception EOFException The set limit would exceed
121                the available data in the stream.
122        */
123        public void setLimit(int length) {
124                remainingBytes = length;
125                limitInPlace = true;
126                return;
127        }
128 
129        /**
130                Clear any limit set by setLimit. After this call no limit checking
131                will be made on any read until a setLimit()) call is made.
132 
133                @return the number of bytes within the limit that have not been read.
134                -1 if no limit was set.
135        */
136        public int clearLimit() {
137                int leftOver = remainingBytes;
138                limitInPlace = false;
139                remainingBytes = -1;
140                return leftOver;
141        }
142 
143        public void setInput(InputStream in) {
144                this.in = in;
145        }
146}

[all classes][org.apache.derby.iapi.services.io]
EMMA 2.0.5312 (C) Vladimir Roubtsov