blob: 1fada57dc7a6ddfdd11f9e130ef835877d27c216 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.io;
import java.util.Arrays;
/**
* A specialized {@link InputStream} that reads bytes from a {@code String} in
* a sequential manner.
*
* @deprecated Use {@link StringReader}
*/
@Deprecated
public class StringBufferInputStream extends InputStream {
/**
* The source string containing the data to read.
*/
protected String buffer;
/**
* The total number of characters in the source string.
*/
protected int count;
/**
* The current position within the source string.
*/
protected int pos;
/**
* Construct a new {@code StringBufferInputStream} with {@code str} as
* source. The size of the stream is set to the {@code length()} of the
* string.
*
* @param str
* the source string for this stream.
* @throws NullPointerException
* if {@code str} is {@code null}.
*/
public StringBufferInputStream(String str) {
if (str == null) {
throw new NullPointerException();
}
buffer = str;
count = str.length();
}
@Override
public synchronized int available() {
return count - pos;
}
/**
* Reads a single byte from the source string and returns it as an integer
* in the range from 0 to 255. Returns -1 if the end of the source string
* has been reached.
*
* @return the byte read or -1 if the end of the source string has been
* reached.
*/
@Override
public synchronized int read() {
return pos < count ? buffer.charAt(pos++) & 0xFF : -1;
}
/**
* Reads at most {@code length} bytes from the source string and stores them
* in the byte array {@code b} starting at {@code offset}.
*
* @param buffer
* the byte array in which to store the bytes read.
* @param offset
* the initial position in {@code b} to store the bytes read from
* this stream.
* @param length
* the maximum number of bytes to store in {@code b}.
* @return the number of bytes actually read or -1 if the end of the source
* string has been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code length < 0}, or if
* {@code offset + length} is greater than the length of
* {@code b}.
* @throws NullPointerException
* if {@code b} is {@code null}.
*/
@Override
public synchronized int read(byte[] buffer, int offset, int length) {
if (buffer == null) {
throw new NullPointerException("buffer == null");
}
Arrays.checkOffsetAndCount(buffer.length, offset, length);
if (length == 0) {
return 0;
}
int copylen = count - pos < length ? count - pos : length;
for (int i = 0; i < copylen; i++) {
buffer[offset + i] = (byte) this.buffer.charAt(pos + i);
}
pos += copylen;
return copylen;
}
/**
* Resets this stream to the beginning of the source string.
*/
@Override
public synchronized void reset() {
pos = 0;
}
/**
* Skips {@code charCount} characters in the source string. It does nothing and
* returns 0 if {@code charCount} is negative. Less than {@code charCount} characters are
* skipped if the end of the source string is reached before the operation
* completes.
*
* @return the number of characters actually skipped.
*/
@Override
public synchronized long skip(long charCount) {
if (charCount <= 0) {
return 0;
}
int numskipped;
if (this.count - pos < charCount) {
numskipped = this.count - pos;
pos = this.count;
} else {
numskipped = (int) charCount;
pos += charCount;
}
return numskipped;
}
}
|
