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 [DynamicByteArrayOutputStream.java]

nameclass, %method, %block, %line, %
DynamicByteArrayOutputStream.java100% (1/1)89%  (16/18)84%  (243/289)83%  (63/76)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class DynamicByteArrayOutputStream100% (1/1)89%  (16/18)84%  (243/289)83%  (63/76)
<static initializer> 100% (1/1)100% (3/3)100% (1/1)
DynamicByteArrayOutputStream (): void 100% (1/1)100% (4/4)100% (2/2)
DynamicByteArrayOutputStream (DynamicByteArrayOutputStream): void 100% (1/1)100% (29/29)100% (8/8)
DynamicByteArrayOutputStream (byte []): void 0%   (0/1)0%   (0/6)0%   (0/3)
DynamicByteArrayOutputStream (int): void 100% (1/1)100% (7/7)100% (3/3)
close (): void 100% (1/1)100% (6/6)100% (3/3)
discardLeft (int): void 100% (1/1)100% (24/24)100% (4/4)
expandBuffer (int): void 100% (1/1)90%  (44/49)85%  (11/13)
getBeginPosition (): int 100% (1/1)100% (3/3)100% (1/1)
getByteArray (): byte [] 100% (1/1)100% (3/3)100% (1/1)
getPosition (): int 100% (1/1)100% (3/3)100% (1/1)
getUsed (): int 100% (1/1)100% (3/3)100% (1/1)
reset (): void 100% (1/1)100% (10/10)100% (4/4)
setBeginPosition (int): void 100% (1/1)90%  (9/10)75%  (3/4)
setPosition (int): void 100% (1/1)100% (29/29)100% (7/7)
write (byte [], int, int): void 100% (1/1)100% (35/35)100% (7/7)
write (int): void 100% (1/1)100% (31/31)100% (6/6)
writeCompleteStream (InputStream, int): void 0%   (0/1)0%   (0/34)0%   (0/7)

1/*
2 
3   Derby - Class org.apache.derby.iapi.services.io.DynamicByteArrayOutputStream
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 org.apache.derby.iapi.services.sanity.SanityManager;
24 
25import java.io.InputStream;
26import java.io.IOException;
27import java.io.OutputStream;
28 
29/**
30        A DynamicByteArrayOutputStream allows writing to a dynamically resizable
31        array of bytes.   In addition to dynamic resizing, this extension allows
32        the user of this class to have more control over the position of the stream
33        and can get a direct reference of the array.
34*/
35public class DynamicByteArrayOutputStream extends OutputStream {
36 
37        private static int INITIAL_SIZE = 4096;
38 
39        private byte[] buf;
40        private int                position;
41        private int                used;                // how many bytes are used
42        private int                beginPosition;
43 
44        public DynamicByteArrayOutputStream() {
45                this(INITIAL_SIZE);
46        }
47 
48        public DynamicByteArrayOutputStream(int size) {
49                super();
50 
51                buf = new byte[size];
52        }
53 
54        public DynamicByteArrayOutputStream(byte[] data) {
55                super();
56 
57                buf = data;
58        }
59 
60        public DynamicByteArrayOutputStream(DynamicByteArrayOutputStream toBeCloned) {
61 
62                byte[] cbuf = toBeCloned.getByteArray();
63                buf = new byte[cbuf.length];
64 
65                write(cbuf, 0, cbuf.length);
66                position = toBeCloned.getPosition();
67                used = toBeCloned.getUsed();
68                beginPosition = toBeCloned.getBeginPosition();
69        }
70 
71        /*
72         *        OutputStream methods
73         */
74        public void write(int b) 
75        {
76                if (position >= buf.length)
77                        expandBuffer(INITIAL_SIZE);
78 
79                buf[position++] = (byte) b;
80 
81                if (position > used)
82                        used = position;
83        }
84        
85        public void write(byte[] b, int off, int len) 
86        {
87                if ((position+len) > buf.length)
88                        expandBuffer(len);
89 
90                System.arraycopy(b, off, buf, position, len);
91                position += len;
92 
93                if (position > used)
94                        used = position;
95        }
96 
97        void writeCompleteStream(InputStream dataIn, int len) throws IOException
98        {
99                if ((position+len) > buf.length)
100                        expandBuffer(len);
101 
102                org.apache.derby.iapi.services.io.InputStreamUtil.readFully(dataIn, buf, position, len);
103                position += len;
104 
105                if (position > used)
106                        used = position;
107        }
108 
109        public void close()
110        {
111                buf = null;
112                reset();
113        }
114 
115        /*
116         *        Specific methods
117         */
118 
119        /**
120                Reset the stream for reuse
121        */
122        public void reset()
123        {
124                position = 0;
125                beginPosition = 0;
126                used = 0;
127        }
128 
129        /**
130                Get a reference to the byte array stored in the byte array output
131                stream. Note that the byte array may be longer that getPosition().
132                Bytes beyond and including the current poistion are invalid.
133        */
134        public byte[] getByteArray()
135        {
136                return buf;
137        }
138 
139        /**
140                Get the number of bytes that was used.
141        */
142        public int getUsed()
143        {
144                return used;
145        }
146 
147        /**
148                Get the current position in the stream
149        */
150        public int getPosition()
151        {
152                return position;
153        }
154 
155        /**
156                Get the current position in the stream
157        */
158        public int getBeginPosition()
159        {
160                return beginPosition;
161        }
162 
163        /**
164                Set the position of the stream pointer.
165                It is up to the caller to make sure the stream has no gap of garbage in
166                it or useful information is not left out at the end because the stream
167                does not remember anything about the previous position.
168        */
169        public void setPosition(int newPosition)
170        {
171                if (newPosition > position)
172                {
173                        if (newPosition > buf.length)
174                                expandBuffer(newPosition - buf.length);
175                }
176 
177                position = newPosition;
178 
179                if (position > used)
180                        used = position;
181 
182                return ;
183        }
184 
185        /**
186                Set the begin position of the stream pointer.
187                If the newBeginPosition is larger than the stream itself,
188                then, the begin position is not set.
189        */
190        public void setBeginPosition(int newBeginPosition)
191        {
192 
193                if (newBeginPosition > buf.length)
194                        return;
195 
196                beginPosition = newBeginPosition;
197        }
198 
199        /**
200                Shrink the buffer left by the amount given. Ie.
201                bytes from 0 to amountToShrinkBy are thrown away
202        */
203        public void discardLeft(int amountToShrinkBy) {
204 
205                System.arraycopy(buf, amountToShrinkBy, buf, 0,
206                        used - amountToShrinkBy);
207 
208                position -= amountToShrinkBy;
209                used -= amountToShrinkBy;
210        }
211 
212        /**
213                Expand the buffer by at least the number of bytes requested in minExtension.
214 
215                To optimize performance and reduce memory copies and allocation, we have a staged buffer
216                expansion.
217 
218                <UL>
219                <LI> buf.length < 128k - increase by 4k
220                <LI> buf.length < 1Mb - increase by 128k
221                <LI> otherwise increase by 1Mb.
222                </UL>
223 
224                In all cases, if minExpansion is greater than the value about then the buffer will
225                be increased by minExtension.
226        */
227        private void expandBuffer(int minExtension)
228        {
229                if (buf.length < (128 * 1024)) {
230                        if (minExtension < INITIAL_SIZE)
231                                minExtension = INITIAL_SIZE;
232                } else if (buf.length < (1024 * 1024)) {
233 
234                        if (minExtension < (128 * 1024))
235                                minExtension = (128 * 1024);
236                } else {
237                        if (minExtension < (1024 * 1024))
238                                minExtension = 1024 * 1024;
239                }
240 
241                int newsize = buf.length + minExtension;
242 
243                byte[] newbuf = new byte[newsize];
244                System.arraycopy(buf, 0, newbuf, 0, buf.length);
245                buf = newbuf;
246        }
247 
248}

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