() {{
197 | put("string", "value");
198 | put(123, "number-key");
199 | }});
200 | assertThrows(ClassCastException.class, runnable);
201 | assertEquals(0, out.toByteArray().length);
202 | }
203 |
204 | @Test
205 | public void testWriteDictionaryNull() throws Exception {
206 | assertThrows(NullPointerException.class, () -> instance.writeDictionary(null));
207 | assertEquals(0, out.toByteArray().length);
208 | }
209 | }
210 |
--------------------------------------------------------------------------------
/src/main/java/com/dampcake/bencode/BencodeOutputStream.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2015 Adam Peck.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.dampcake.bencode;
17 |
18 | import java.io.ByteArrayOutputStream;
19 | import java.io.FilterOutputStream;
20 | import java.io.IOException;
21 | import java.io.OutputStream;
22 | import java.nio.ByteBuffer;
23 | import java.nio.charset.Charset;
24 | import java.util.Map;
25 | import java.util.SortedMap;
26 | import java.util.TreeMap;
27 |
28 | /**
29 | * OutputStream for writing bencoded data.
30 | *
31 | * @author Adam Peck
32 | */
33 | public class BencodeOutputStream extends FilterOutputStream {
34 |
35 | private final Charset charset;
36 |
37 | /**
38 | * Creates a new BencodeOutputStream that writes to the {@link OutputStream} passed and uses the {@link Charset} passed for encoding the data.
39 | *
40 | * @param out the {@link OutputStream} to write to
41 | * @param charset the {@link Charset} to use
42 | *
43 | * @throws NullPointerException if the {@link Charset} passed is null
44 | */
45 | public BencodeOutputStream(final OutputStream out, final Charset charset) {
46 | super(out);
47 |
48 | if (charset == null) throw new NullPointerException("charset cannot be null");
49 | this.charset = charset;
50 | }
51 |
52 | /**
53 | * Creates a new BencodeOutputStream that writes to the {@link OutputStream} passed and uses UTF-8 {@link Charset} for encoding the data.
54 | *
55 | * @param out the {@link OutputStream} to write to
56 | */
57 | public BencodeOutputStream(final OutputStream out) {
58 | this(out, Bencode.DEFAULT_CHARSET);
59 | }
60 |
61 | /**
62 | * Gets the {@link Charset} the stream was created with.
63 | *
64 | * @return the {@link Charset} of the stream
65 | */
66 | public Charset getCharset() {
67 | return charset;
68 | }
69 |
70 | /**
71 | * Writes the passed {@link String} to the stream.
72 | *
73 | * @param s the {@link String} to write to the stream
74 | *
75 | * @throws NullPointerException if the String is null
76 | * @throws IOException if the underlying stream throws
77 | */
78 | public void writeString(final String s) throws IOException {
79 | write(encode(s));
80 | }
81 |
82 | /**
83 | * Writes the passed {@link ByteBuffer} to the stream.
84 | *
85 | * @param buff the {@link ByteBuffer} to write to the stream
86 | *
87 | * @throws NullPointerException if the {@link ByteBuffer} is null
88 | * @throws IOException if the underlying stream throws
89 | *
90 | * @since 1.3
91 | */
92 | public void writeString(final ByteBuffer buff) throws IOException {
93 | write(encode(buff.array()));
94 | }
95 |
96 | /**
97 | * Writes the passed byte[] to the stream.
98 | *
99 | * @param array the byte[] to write to the stream
100 | *
101 | * @throws NullPointerException if the byte[] is null
102 | * @throws IOException if the underlying stream throws
103 | *
104 | * @since 1.4.1
105 | */
106 | public void writeString(final byte[] array) throws IOException {
107 | write(encode(array));
108 | }
109 |
110 | /**
111 | * Writes the passed {@link Number} to the stream.
112 | *
113 | * The number is converted to a {@link Long}, meaning any precision is lost as it not supported by the bencode spec.
114 | *
115 | *
116 | * @param n the {@link Number} to write to the stream
117 | *
118 | * @throws NullPointerException if the {@link Number} is null
119 | * @throws IOException if the underlying stream throws
120 | */
121 | public void writeNumber(final Number n) throws IOException {
122 | write(encode(n));
123 | }
124 |
125 | /**
126 | * Writes the passed {@link Iterable} to the stream.
127 | *
128 | * Data contained in the {@link Iterable} is written as the correct type. Any {@link Iterable} is written as a List,
129 | * any {@link Number} as a Number, any {@link Map} as a Dictionary and any other {@link Object} is written as a String
130 | * calling the {@link Object#toString()} method.
131 | *
132 | * @param l the {@link Iterable} to write to the stream
133 | *
134 | * @throws NullPointerException if the {@link Iterable} is null
135 | * @throws IOException if the underlying stream throws
136 | */
137 | public void writeList(final Iterable l) throws IOException {
138 | write(encode(l));
139 | }
140 |
141 | /**
142 | * Writes the passed {@link Map} to the stream.
143 | *
144 | * Data contained in the {@link Map} is written as the correct type. Any {@link Iterable} is written as a List,
145 | * any {@link Number} as a Number, any {@link Map} as a Dictionary and any other {@link Object} is written as a String
146 | * calling the {@link Object#toString()} method.
147 | *
148 | * @param m the {@link Map} to write to the stream
149 | *
150 | * @throws NullPointerException if the {@link Map} is null
151 | * @throws IOException if the underlying stream throws
152 | */
153 | public void writeDictionary(final Map m) throws IOException {
154 | write(encode(m));
155 | }
156 |
157 | private byte[] encode(final String s) throws IOException {
158 | if (s == null) throw new NullPointerException("s cannot be null");
159 |
160 | ByteArrayOutputStream buffer = new ByteArrayOutputStream();
161 | byte[] bytes = s.getBytes(charset);
162 | buffer.write(Integer.toString(bytes.length).getBytes(charset));
163 | buffer.write(Bencode.SEPARATOR);
164 | buffer.write(bytes);
165 |
166 | return buffer.toByteArray();
167 | }
168 |
169 | private byte[] encode(final byte[] b) throws IOException {
170 | if (b == null) throw new NullPointerException("b cannot be null");
171 |
172 | ByteArrayOutputStream buffer = new ByteArrayOutputStream();
173 |
174 | buffer.write(Integer.toString(b.length).getBytes(charset));
175 | buffer.write(Bencode.SEPARATOR);
176 | buffer.write(b);
177 |
178 | return buffer.toByteArray();
179 | }
180 |
181 | private byte[] encode(final Number n) throws IOException {
182 | if (n == null) throw new NullPointerException("n cannot be null");
183 |
184 | ByteArrayOutputStream buffer = new ByteArrayOutputStream();
185 | buffer.write(Bencode.NUMBER);
186 | buffer.write(Long.toString(n.longValue()).getBytes(charset));
187 | buffer.write(Bencode.TERMINATOR);
188 |
189 | return buffer.toByteArray();
190 | }
191 |
192 | private byte[] encode(final Iterable l) throws IOException {
193 | if (l == null) throw new NullPointerException("l cannot be null");
194 |
195 | ByteArrayOutputStream buffer = new ByteArrayOutputStream();
196 | buffer.write(Bencode.LIST);
197 | for (Object o : l)
198 | buffer.write(encodeObject(o));
199 | buffer.write(Bencode.TERMINATOR);
200 |
201 | return buffer.toByteArray();
202 | }
203 |
204 | private byte[] encode(final Map m) throws IOException {
205 | if (m == null) throw new NullPointerException("m cannot be null");
206 |
207 | Map map;
208 | if (!(m instanceof SortedMap))
209 | map = new TreeMap<>(m);
210 | else
211 | map = m;
212 |
213 | ByteArrayOutputStream buffer = new ByteArrayOutputStream();
214 | buffer.write(Bencode.DICTIONARY);
215 | for (Map.Entry e : map.entrySet()) {
216 | buffer.write(encode(e.getKey().toString()));
217 | buffer.write(encodeObject(e.getValue()));
218 | }
219 | buffer.write(Bencode.TERMINATOR);
220 |
221 | return buffer.toByteArray();
222 | }
223 |
224 | private byte[] encodeObject(final Object o) throws IOException {
225 | if (o == null) throw new NullPointerException("Cannot write null objects");
226 |
227 | if (o instanceof Number)
228 | return encode((Number) o);
229 | if (o instanceof Iterable)
230 | return encode((Iterable) o);
231 | if (o instanceof Map)
232 | return encode((Map) o);
233 | if (o instanceof ByteBuffer)
234 | return encode(((ByteBuffer) o).array());
235 | if (o instanceof byte[])
236 | return encode((byte[]) o);
237 |
238 | return encode(o.toString());
239 | }
240 | }
241 |
--------------------------------------------------------------------------------
/src/main/java/com/dampcake/bencode/Bencode.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2015 Adam Peck.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.dampcake.bencode;
17 |
18 | import java.io.ByteArrayInputStream;
19 | import java.io.ByteArrayOutputStream;
20 | import java.io.IOException;
21 | import java.nio.charset.Charset;
22 | import java.util.Map;
23 |
24 | /**
25 | * Bencode encoder/decoder.
26 | *
27 | * @author Adam Peck
28 | * @since 1.1
29 | */
30 | public final class Bencode {
31 |
32 | /** Default Charset used by the Streams */
33 | static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
34 |
35 | /** Number Marker */
36 | static final char NUMBER = 'i';
37 |
38 | /** List Marker */
39 | static final char LIST = 'l';
40 |
41 | /** Dictionary Marker */
42 | static final char DICTIONARY = 'd';
43 |
44 | /** End of type Marker */
45 | static final char TERMINATOR = 'e';
46 |
47 | /** Separator between length and string */
48 | static final char SEPARATOR = ':';
49 |
50 | private final Charset charset;
51 | private final boolean useBytes;
52 |
53 | /**
54 | * Create a new Bencoder using the default {@link Charset} (UTF-8) and useBytes as false.
55 | *
56 | * @see #Bencode(Charset, boolean)
57 | */
58 | public Bencode() {
59 | this(DEFAULT_CHARSET);
60 | }
61 |
62 | /**
63 | * Creates a new Bencoder using the {@link Charset} passed for encoding/decoding and useBytes as false.
64 | *
65 | * @param charset the {@link Charset} to use
66 | *
67 | * @throws NullPointerException if the {@link Charset} passed is null
68 | *
69 | * @see #Bencode(Charset, boolean)
70 | */
71 | public Bencode(final Charset charset) {
72 | this(charset, false);
73 | }
74 |
75 | /**
76 | * Creates a new Bencoder using the boolean passed to control String parsing.
77 | *
78 | * @param useBytes {@link #Bencode(Charset, boolean)}
79 | *
80 | * @since 1.3
81 | */
82 | public Bencode(final boolean useBytes) {
83 | this(DEFAULT_CHARSET, useBytes);
84 | }
85 |
86 | /**
87 | * Creates a new Bencoder using the {@link Charset} passed for encoding/decoding and boolean passed to control String parsing.
88 | *
89 | * If useBytes is false, then dictionary values that contain byte string data will be coerced to a {@link String}.
90 | * if useBytes is true, then dictionary values that contain byte string data will be coerced to a {@link java.nio.ByteBuffer}.
91 | *
92 | * @param charset the {@link Charset} to use
93 | * @param useBytes true to have dictionary byte data to stay as bytes
94 | *
95 | * @throws NullPointerException if the {@link Charset} passed is null
96 | *
97 | * @since 1.3
98 | */
99 | public Bencode(final Charset charset, final boolean useBytes) {
100 | if (charset == null) throw new NullPointerException("charset cannot be null");
101 |
102 | this.charset = charset;
103 | this.useBytes = useBytes;
104 | }
105 |
106 | /**
107 | * Gets the {@link Charset} the coder was created with.
108 | *
109 | * @return the {@link Charset} of the coder
110 | */
111 | public Charset getCharset() {
112 | return charset;
113 | }
114 |
115 | /**
116 | * Determines the first {@link Type} contained within the byte array.
117 | *
118 | * @param bytes the bytes to determine the {@link Type} for
119 | *
120 | * @return the {@link Type} or {@link Type#UNKNOWN} if it cannot be determined
121 | *
122 | * @throws NullPointerException if bytes is null
123 | * @throws BencodeException if an error occurs during detection
124 | */
125 | public Type type(final byte[] bytes) {
126 | if (bytes == null) throw new NullPointerException("bytes cannot be null");
127 |
128 | try (BencodeInputStream in = new BencodeInputStream(new ByteArrayInputStream(bytes), charset, useBytes)) {
129 | return in.nextType();
130 | } catch (Throwable t) {
131 | throw new BencodeException("Exception thrown during type detection", t);
132 | }
133 | }
134 |
135 | /**
136 | * Decodes a bencode encoded byte array.
137 | *
138 | * @param inferred from the {@link Type} parameter
139 | * @param bytes the bytes to decode
140 | * @param type the {@link Type} to decode as
141 | *
142 | * @return the decoded object
143 | *
144 | * @throws NullPointerException if bytes or type is null
145 | * @throws IllegalArgumentException if type is {@link Type#UNKNOWN}
146 | * @throws BencodeException if an error occurs during decoding
147 | */
148 | @SuppressWarnings("unchecked")
149 | public T decode(final byte[] bytes, final Type type) {
150 | if (bytes == null) throw new NullPointerException("bytes cannot be null");
151 | if (type == null) throw new NullPointerException("type cannot be null");
152 | if (type == Type.UNKNOWN) throw new IllegalArgumentException("type cannot be UNKNOWN");
153 |
154 | try (BencodeInputStream in = new BencodeInputStream(new ByteArrayInputStream(bytes), charset, useBytes)) {
155 | if (type == Type.NUMBER)
156 | return (T) in.readNumber();
157 | if (type == Type.LIST)
158 | return (T) in.readList();
159 | if (type == Type.DICTIONARY)
160 | return (T) in.readDictionary();
161 | return (T) in.readString();
162 | } catch (Throwable t) {
163 | throw new BencodeException("Exception thrown during decoding", t);
164 | }
165 | }
166 |
167 | /**
168 | * Encodes the passed {@link String}.
169 | *
170 | * @param s the {@link String} to encode
171 | *
172 | * @return the encoded bytes
173 | *
174 | * @throws NullPointerException if the {@link String} is null
175 | * @throws BencodeException if an error occurs during encoding
176 | */
177 | public byte[] encode(final String s) {
178 | if (s == null) throw new NullPointerException("s cannot be null");
179 |
180 | return encode(bencode -> bencode.writeString(s));
181 | }
182 |
183 | /**
184 | * Encodes the passed {@link Number}.
185 | *
186 | * The number is converted to a {@link Long}, meaning any precision is lost as it not supported by the bencode spec.
187 | *
188 | * @param n the {@link Number} to encode
189 | *
190 | * @return the encoded bytes
191 | *
192 | * @throws NullPointerException if the {@link Number} is null
193 | * @throws BencodeException if an error occurs during encoding
194 | */
195 | public byte[] encode(final Number n) {
196 | if (n == null) throw new NullPointerException("n cannot be null");
197 |
198 | return encode(bencode -> bencode.writeNumber(n));
199 | }
200 |
201 | /**
202 | * Encodes the passed {@link Iterable} as a bencode List.
203 | *
204 | * Data contained in the List is written as the correct type. Any {@link Iterable} is written as a List,
205 | * any {@link Number} as a Number, any {@link Map} as a Dictionary and any other {@link Object} is written as a String
206 | * calling the {@link Object#toString()} method.
207 | *
208 | * @param l the {@link Iterable} to encode
209 | *
210 | * @return the encoded bytes
211 | *
212 | * @throws NullPointerException if the List is null
213 | * @throws BencodeException if an error occurs during encoding
214 | */
215 | public byte[] encode(final Iterable l) {
216 | if (l == null) throw new NullPointerException("l cannot be null");
217 |
218 | return encode(bencode -> bencode.writeList(l));
219 | }
220 |
221 | /**
222 | * Encodes the passed {@link Map} as a bencode Dictionary.
223 | *
224 | * Data contained in the Dictionary is written as the correct type. Any {@link Iterable} is written as a List,
225 | * any {@link Number} as a Number, any {@link Map} as a Dictionary and any other {@link Object} is written as a String
226 | * calling the {@link Object#toString()} method.
227 | *
228 | * @param m the {@link Map} to encode
229 | *
230 | * @return the encoded bytes
231 | *
232 | * @throws NullPointerException if the Map is null
233 | * @throws BencodeException if an error occurs during encoding
234 | */
235 | public byte[] encode(final Map m) {
236 | if (m == null) throw new NullPointerException("m cannot be null");
237 |
238 | return encode(bencode -> bencode.writeDictionary(m));
239 | }
240 |
241 | private byte[] encode(final ThrowingConsumer function) {
242 | ByteArrayOutputStream out = new ByteArrayOutputStream();
243 |
244 | try (BencodeOutputStream bencode = new BencodeOutputStream(out, charset)) {
245 | function.accept(bencode);
246 | } catch (Throwable t) {
247 | throw new BencodeException("Exception thrown during encoding", t);
248 | }
249 |
250 | return out.toByteArray();
251 | }
252 |
253 | @FunctionalInterface
254 | public interface ThrowingConsumer {
255 | public void accept(T t) throws IOException;
256 | }
257 | }
258 |
--------------------------------------------------------------------------------
/src/main/java/com/dampcake/bencode/BencodeInputStream.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2015 Adam Peck.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.dampcake.bencode;
17 |
18 | import java.io.EOFException;
19 | import java.io.FilterInputStream;
20 | import java.io.IOException;
21 | import java.io.InputStream;
22 | import java.io.InvalidObjectException;
23 | import java.io.PushbackInputStream;
24 | import java.math.BigDecimal;
25 | import java.nio.ByteBuffer;
26 | import java.nio.charset.Charset;
27 | import java.util.ArrayList;
28 | import java.util.LinkedHashMap;
29 | import java.util.List;
30 | import java.util.Map;
31 |
32 | /**
33 | * InputStream for reading bencoded data.
34 | *
35 | * @author Adam Peck
36 | */
37 | public class BencodeInputStream extends FilterInputStream {
38 |
39 | // EOF Constant
40 | private static final int EOF = -1;
41 |
42 | private final Charset charset;
43 | private final boolean useBytes;
44 | private final PushbackInputStream in;
45 |
46 | /**
47 | * Creates a new BencodeInputStream that reads from the {@link InputStream} passed and uses the {@link Charset} passed for decoding the data
48 | * and boolean passed to control String parsing.
49 | *
50 | * If useBytes is false, then dictionary values that contain byte string data will be coerced to a {@link String}.
51 | * if useBytes is true, then dictionary values that contain byte string data will be coerced to a {@link ByteBuffer}.
52 | *
53 | * @param in the {@link InputStream} to read from
54 | * @param charset the {@link Charset} to use
55 | * @param useBytes controls coercion of dictionary values
56 | *
57 | * @throws NullPointerException if the {@link Charset} passed is null
58 | *
59 | * @since 1.3
60 | */
61 | public BencodeInputStream(final InputStream in, final Charset charset, boolean useBytes) {
62 | super(new PushbackInputStream(in));
63 | this.in = (PushbackInputStream) super.in;
64 |
65 | if (charset == null) throw new NullPointerException("charset cannot be null");
66 | this.charset = charset;
67 | this.useBytes = useBytes;
68 | }
69 |
70 | /**
71 | * Creates a new BencodeInputStream that reads from the {@link InputStream} passed and uses the {@link Charset} passed for decoding the data
72 | * and coerces dictionary values to a {@link String}.
73 | *
74 | * @param in the {@link InputStream} to read from
75 | * @param charset the {@link Charset} to use
76 | *
77 | * @throws NullPointerException if the {@link Charset} passed is null
78 | *
79 | * @see #BencodeInputStream(InputStream, Charset, boolean)
80 | */
81 | public BencodeInputStream(final InputStream in, final Charset charset) {
82 | this(in, charset, false);
83 | }
84 |
85 | /**
86 | * Creates a new BencodeInputStream that reads from the {@link InputStream} passed and uses the UTF-8 {@link Charset} for decoding the data
87 | * and coerces dictionary values to a {@link String}.
88 | *
89 | * @param in the {@link InputStream} to read from
90 | *
91 | * @see #BencodeInputStream(InputStream, Charset, boolean)
92 | */
93 | public BencodeInputStream(final InputStream in) {
94 | this(in, Bencode.DEFAULT_CHARSET);
95 | }
96 |
97 | /**
98 | * Gets the {@link Charset} the stream was created with.
99 | *
100 | * @return the {@link Charset} of the stream
101 | */
102 | public Charset getCharset() {
103 | return charset;
104 | }
105 |
106 | private int peek() throws IOException {
107 | int b = in.read();
108 | in.unread(b);
109 | return b;
110 | }
111 |
112 | /**
113 | * Peeks at the next {@link Type}.
114 | *
115 | * @return the next {@link Type} available
116 | *
117 | * @throws IOException if the underlying stream throws
118 | * @throws EOFException if the end of the stream has been reached
119 | */
120 | public Type nextType() throws IOException {
121 | int token = peek();
122 | checkEOF(token);
123 |
124 | return typeForToken(token);
125 | }
126 |
127 | private Type typeForToken(int token) {
128 | for (Type type : Type.values()) {
129 | if (type.validate(token))
130 | return type;
131 | }
132 |
133 | return Type.UNKNOWN;
134 | }
135 |
136 | /**
137 | * Reads a {@link String} from the stream.
138 | *
139 | * @return the {@link String} read from the stream
140 | *
141 | * @throws IOException if the underlying stream throws
142 | * @throws EOFException if the end of the stream has been reached
143 | * @throws InvalidObjectException if the next type in the stream is not a String
144 | */
145 | public String readString() throws IOException {
146 | return new String(readStringBytesInternal(), getCharset());
147 | }
148 |
149 | /**
150 | * Reads a Byte String from the stream.
151 | *
152 | * @return the {@link ByteBuffer} read from the stream
153 | *
154 | * @throws IOException if the underlying stream throws
155 | * @throws EOFException if the end of the stream has been reached
156 | * @throws InvalidObjectException if the next type in the stream is not a String
157 | *
158 | * @since 1.3
159 | */
160 | public ByteBuffer readStringBytes() throws IOException {
161 | return ByteBuffer.wrap(readStringBytesInternal());
162 | }
163 |
164 | private byte[] readStringBytesInternal() throws IOException {
165 | int token = in.read();
166 | validateToken(token, Type.STRING);
167 |
168 | StringBuilder buffer = new StringBuilder();
169 | buffer.append((char) token);
170 | while ((token = in.read()) != Bencode.SEPARATOR) {
171 | validateToken(token, Type.STRING);
172 |
173 | buffer.append((char) token);
174 | }
175 |
176 | int length = Integer.parseInt(buffer.toString());
177 | byte[] bytes = new byte[length];
178 | read(bytes);
179 | return bytes;
180 | }
181 |
182 | /**
183 | * Reads a Number from the stream.
184 | *
185 | * @return the Number read from the stream
186 | *
187 | * @throws IOException if the underlying stream throws
188 | * @throws EOFException if the end of the stream has been reached
189 | * @throws InvalidObjectException if the next type in the stream is not a Number
190 | */
191 | public Long readNumber() throws IOException {
192 | int token = in.read();
193 | validateToken(token, Type.NUMBER);
194 |
195 | StringBuilder buffer = new StringBuilder();
196 | while ((token = in.read()) != Bencode.TERMINATOR) {
197 | checkEOF(token);
198 |
199 | buffer.append((char) token);
200 | }
201 |
202 | return new BigDecimal(buffer.toString()).longValue();
203 | }
204 |
205 | /**
206 | * Reads a List from the stream.
207 | *
208 | * @return the List read from the stream
209 | *
210 | * @throws IOException if the underlying stream throws
211 | * @throws EOFException if the end of the stream has been reached
212 | * @throws InvalidObjectException if the next type in the stream is not a List, or the list contains invalid types
213 | */
214 | public List