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

COVERAGE SUMMARY FOR SOURCE FILE [UTF8Reader.java]

nameclass, %method, %block, %line, %
UTF8Reader.java100% (1/1)83%  (10/12)79%  (541/688)79%  (116.4/147)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class UTF8Reader100% (1/1)83%  (10/12)79%  (541/688)79%  (116.4/147)
UTF8Reader (InputStream, long, ConnectionChild, Object): void 100% (1/1)86%  (30/35)98%  (8.8/9)
close (): void 100% (1/1)77%  (17/22)96%  (5.8/6)
closeIn (): void 100% (1/1)50%  (11/22)66%  (4/6)
fillBuffer (): boolean 100% (1/1)74%  (201/270)73%  (35.8/49)
read (): int 100% (1/1)80%  (36/45)78%  (7/9)
read (char [], int, int): int 100% (1/1)85%  (52/61)86%  (12/14)
readAsciiInto (byte [], int, int): int 100% (1/1)97%  (76/78)94%  (17/18)
readInto (StringBuffer, int): int 100% (1/1)91%  (49/54)92%  (11/12)
readUnsignedShort (): int 100% (1/1)83%  (20/24)80%  (4/5)
skip (long): long 100% (1/1)84%  (49/58)85%  (11/13)
utfFormatException (): IOException 0%   (0/1)0%   (0/9)0%   (0/3)
utfFormatException (String): IOException 0%   (0/1)0%   (0/10)0%   (0/3)

1/*
2 
3   Derby - Class org.apache.derby.impl.jdbc.UTF8Reader
4 
5   Copyright 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.impl.jdbc;
22 
23import java.io.InputStream;
24import java.io.Reader;
25import java.io.IOException;
26import java.io.UTFDataFormatException;
27import java.io.EOFException;
28import java.sql.SQLException;
29 
30/**
31*/
32public final class UTF8Reader extends Reader
33{
34 
35        private InputStream in;
36        private final long         utfLen;        // bytes
37        private long        utfCount;                // bytes
38        private long                readerCharCount; // characters
39        private long                maxFieldSize;        // characeters
40 
41        private char[]                buffer = new char[8 * 1024];
42        private int                        charactersInBuffer;        // within buffer
43        private int                        readPositionInBuffer;
44 
45        private boolean                noMoreReads;
46 
47    // maintain a reference to the parent object so that it can't get 
48    // garbage collected until we are done with the stream.
49    private ConnectionChild      parent;
50 
51        public UTF8Reader(
52    InputStream in,
53        long maxFieldSize,
54    ConnectionChild      parent,
55        Object synchronization) 
56        throws IOException
57        {
58                super(synchronization);
59 
60                this.in     = in;
61                this.maxFieldSize = maxFieldSize;
62                this.parent = parent;
63 
64                synchronized (lock) {
65                        this.utfLen = readUnsignedShort();
66                }
67        }
68 
69        /*
70        ** Reader implemention.
71        */
72        public int read() throws IOException
73        {
74                synchronized (lock) {
75 
76                        // check if closed..
77                        if (noMoreReads)
78                                throw new IOException();
79 
80                        if (readPositionInBuffer >= charactersInBuffer) {
81                                if (fillBuffer()) {
82                                        return -1;
83                                }
84                                readPositionInBuffer = 0;
85                        }
86 
87                        return buffer[readPositionInBuffer++];
88                }
89        }
90 
91        public int read(char[] cbuf, int off, int len) throws IOException
92        {
93                synchronized (lock) {
94                        // check if closed..
95                        if (noMoreReads)
96                                throw new IOException();
97 
98                        if (readPositionInBuffer >= charactersInBuffer) {
99                                if (fillBuffer()) {
100                                        return -1;
101                                }
102                                readPositionInBuffer = 0;
103                        }
104 
105                        int remainingInBuffer = charactersInBuffer - readPositionInBuffer;
106 
107                        if (len > remainingInBuffer)
108                                len = remainingInBuffer;
109 
110                        System.arraycopy(buffer, readPositionInBuffer, cbuf, off, len);
111                        readPositionInBuffer += len;
112 
113                        return len;
114                }
115        }
116 
117        public long skip(long len) throws IOException {
118                synchronized (lock) {
119                        // check if closed..
120                        if (noMoreReads)
121                                throw new IOException();
122 
123                        if (readPositionInBuffer >= charactersInBuffer) {
124                                // do somthing
125                                if (fillBuffer()) {
126                                        return -1;
127                                }
128                                readPositionInBuffer = 0;
129                        }
130 
131                        int remainingInBuffer = charactersInBuffer - readPositionInBuffer;
132 
133                        if (len > remainingInBuffer)
134                                len = remainingInBuffer;
135 
136                        readPositionInBuffer += len;
137 
138                        return len;
139                }
140 
141        }
142 
143        public void close()
144        {
145                synchronized (lock) {
146                        closeIn();
147                        parent  = null;
148                        noMoreReads = true;
149                }
150        }
151 
152        /*
153        ** Methods just for Cloudscape's JDBC driver
154        */
155 
156        public int readInto(StringBuffer sb, int len) throws IOException {
157 
158                synchronized (lock) {
159                        if (readPositionInBuffer >= charactersInBuffer) {
160                                if (fillBuffer()) {
161                                        return -1;
162                                }
163                                readPositionInBuffer = 0;
164                        }
165 
166                        int remainingInBuffer = charactersInBuffer - readPositionInBuffer;
167 
168                        if (len > remainingInBuffer)
169                                len = remainingInBuffer;
170                        sb.append(buffer, readPositionInBuffer, len);
171 
172                        readPositionInBuffer += len;
173 
174                        return len;
175                }
176        }
177        int readAsciiInto(byte[] abuf, int off, int len) throws IOException {
178 
179                synchronized (lock) {
180                        if (readPositionInBuffer >= charactersInBuffer) {
181                                if (fillBuffer()) {
182                                        return -1;
183                                }
184                                readPositionInBuffer = 0;
185                        }
186 
187                        int remainingInBuffer = charactersInBuffer - readPositionInBuffer;
188 
189                        if (len > remainingInBuffer)
190                                len = remainingInBuffer;
191 
192                        char[] lbuffer = buffer;
193                        for (int i = 0; i < len; i++) {
194                                char c = lbuffer[readPositionInBuffer + i];
195                                byte cb;
196                                if (c <= 255)
197                                        cb = (byte) c;
198                                else
199                                        cb = (byte) '?'; // Question mark - out of range character.
200 
201                                abuf[off + i] = cb;
202                        }
203 
204                        readPositionInBuffer += len;
205 
206                        return len;
207                }
208        }
209 
210        /*
211        ** internal implementation
212        */
213 
214 
215        private void closeIn() {
216                if (in != null) {
217                        try {
218                                in.close();
219                        } catch (IOException ioe) {
220                        } finally {
221                                in = null;
222                        }
223                }
224        }
225        private IOException utfFormatException(String s) {
226                noMoreReads = true;
227                closeIn();
228                return new UTFDataFormatException(s);
229        }
230 
231        private IOException utfFormatException() {
232                noMoreReads = true;
233                closeIn();
234                return new UTFDataFormatException();
235        }
236 
237        /**
238                Fill the buffer, return true if eof has been reached.
239        */
240        private boolean fillBuffer() throws IOException
241        {
242                if (in == null)
243                        return true;
244 
245                charactersInBuffer = 0;
246 
247                try {
248                try {
249                
250                        parent.setupContextStack();
251 
252readChars:
253                while (
254                                (charactersInBuffer < buffer.length) &&
255                            ((utfCount < utfLen) || (utfLen == 0)) &&
256                                ((maxFieldSize == 0) || (readerCharCount < maxFieldSize))
257                          )
258                {
259                        int c = in.read();
260                        if (c == -1) {
261                                if (utfLen == 0) {
262                                        closeIn();
263                                        break readChars;
264                                }
265                                throw utfFormatException();
266                        }
267 
268                        int finalChar;
269                        switch (c >> 4) { 
270                                case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
271                                        // 0xxxxxxx
272                                        utfCount++;
273                                        finalChar = c;
274                                        break;
275 
276                                case 12: case 13:
277                                        {
278                                        // 110x xxxx   10xx xxxx
279                                        utfCount += 2;
280                                        int char2 = in.read();
281                                        if (char2 == -1)
282                                                throw utfFormatException();
283 
284                                        if ((char2 & 0xC0) != 0x80)
285                                                throw utfFormatException();                  
286                                        finalChar = (((c & 0x1F) << 6) | (char2 & 0x3F));
287                                        break;
288                                        }
289 
290                                case 14:
291                                        {
292                                        // 1110 xxxx  10xx xxxx  10xx xxxx
293                                        utfCount += 3;
294                                        int char2 = in.read();
295                                        int char3 = in.read();
296                                        if (char2 == -1 || char3 == -1)
297                                                throw utfFormatException();
298 
299                                        if ((c == 0xE0) && (char2 == 0) && (char3 == 0))
300                                        {
301                                                if (utfLen == 0) {
302                                                        // we reached the end of a long string,
303                                                        // that was terminated with
304                                                        // (11100000, 00000000, 00000000)
305                                                        closeIn();
306                                                        break readChars;
307                                                }
308                                                throw utfFormatException();
309                                        }
310 
311                                        if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))
312                                                throw utfFormatException();        
313 
314                                        finalChar = (((c & 0x0F) << 12) |
315                                                           ((char2 & 0x3F) << 6) |
316                                                           ((char3 & 0x3F) << 0));
317                                        }
318                                        break;
319 
320                                default:
321                                        // 10xx xxxx,  1111 xxxx
322                                        throw utfFormatException();                  
323                        }
324 
325                        buffer[charactersInBuffer++] = (char) finalChar;
326                        readerCharCount++;
327                }
328                if (utfLen != 0 && utfCount > utfLen) 
329                        throw utfFormatException("utfCount " + utfCount + " utfLen " + utfLen);                  
330 
331                if (charactersInBuffer != 0)
332                        return false;
333 
334                closeIn();
335                return true;
336                } finally {
337                        parent.restoreContextStack();
338                }
339                } catch (SQLException sqle) {
340                        throw new IOException(sqle.getSQLState() + ":" + sqle.getMessage());
341                }
342        }
343 
344 
345        // this method came from java.io.DataInputStream
346    private final int readUnsignedShort() throws IOException {
347                int ch1 = in.read();
348                int ch2 = in.read();
349                if ((ch1 | ch2) < 0)
350                        throw new EOFException();
351 
352                return (ch1 << 8) + (ch2 << 0);
353        }
354}

[all classes][org.apache.derby.impl.jdbc]
EMMA 2.0.5312 (C) Vladimir Roubtsov