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
|
/* Copyright (C) 1998, 1999 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();
buf = buffer;
count = offset + length;
if (count > buf.length)
count = buf.length;
pos = offset;
// TBD: What should we do if pos is neg. or > count? E.g. throw exc. or:
// if (pos < 0 || pos > count)
// pos = 0;
markedPos = pos;
}
public void close()
{
synchronized (lock)
{
buf = null;
}
}
public void mark(int readAheadLimit)
{
synchronized (lock)
{
// 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();
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();
/* 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;
}
}
public boolean ready() throws IOException
{
if (buf == null)
throw new IOException();
return true;
}
public void reset() throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException();
pos = markedPos;
}
}
public long skip(long n) throws IOException
{
synchronized (lock)
{
if (buf == null)
throw new IOException();
// 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;
}
}
}
|
