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
152
153
154
155
156
157
158
|
/* Copyright (C) 1998, 1999, 2001 Free Software Foundation
This file is part of libgcj.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.io;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date October 16, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct
*/
public class CharArrayReader extends Reader
{
/* An array of chars provided by the creator of the stream. */
protected char[] buf;
/* Position of the next char in buf to be read. */
protected int pos;
/* The currently marked position in the stream. */
protected int markedPos;
/* The index in buf one greater than the last valid character. */
protected int count;
public CharArrayReader(char[] buffer)
{
this(buffer, 0, buffer.length);
}
public CharArrayReader(char[] buffer, int offset, int length)
{
super();
if (offset < 0 || length < 0 || offset > buffer.length)
throw new IllegalArgumentException();
buf = buffer;
count = offset + length;
if (count > buf.length)
count = buf.length;
pos = offset;
markedPos = pos;
}
public void close()
{
synchronized (lock)
{
buf = null;
}
}
public void mark(int readAheadLimit) throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException("Stream closed");
// readAheadLimit is ignored per Java Class Lib. book, p. 318.
markedPos = pos;
}
}
public boolean markSupported()
{
return true;
}
public int read() throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException("Stream closed");
if (pos < 0)
throw new ArrayIndexOutOfBoundsException(pos);
if (pos < count)
return ((int) buf[pos++]) & 0xFFFF;
return -1;
}
}
public int read(char[] b, int off, int len) throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException("Stream closed");
/* Don't need to check pos value, arraycopy will check it. */
if (off < 0 || len < 0 || off + len > b.length)
throw new ArrayIndexOutOfBoundsException();
if (pos >= count)
return -1;
int numChars = Math.min(count - pos, len);
System.arraycopy(buf, pos, b, off, numChars);
pos += numChars;
return numChars;
}
}
/** Return true if more characters are available to be read.
*
* @specnote The JDK 1.3 API docs are wrong here. This method will
* return false if there are no more characters available.
*/
public boolean ready() throws IOException
{
if (buf == null)
throw new IOException("Stream closed");
return (pos < count);
}
public void reset() throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException("Stream closed");
pos = markedPos;
}
}
public long skip(long n) throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException("Stream closed");
// Even though the var numChars is a long, in reality it can never
// be larger than an int since the result of subtracting 2 positive
// ints will always fit in an int. Since we have to return a long
// anyway, numChars might as well just be a long.
long numChars = Math.min((long) (count - pos), n < 0 ? 0L : n);
pos += numChars;
return numChars;
}
}
}
|
