Panda3D
Loading...
Searching...
No Matches
streamReader.I
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file streamReader.I
10 * @author drose
11 * @date 2002-08-04
12 */
13
14/**
15 *
16 */
17INLINE StreamReader::
18StreamReader(std::istream &in) :
19 _in(&in),
20 _owns_stream(false)
21{
22}
23
24/**
25 * If owns_stream is true, the stream pointer will be deleted when the
26 * StreamReader destructs.
27 */
28INLINE StreamReader::
29StreamReader(std::istream *in, bool owns_stream) :
30 _in(in),
31 _owns_stream(owns_stream)
32{
33}
34
35/**
36 * The copy constructor does not copy ownership of the stream.
37 */
38INLINE StreamReader::
39StreamReader(const StreamReader &copy) :
40 _in(copy._in),
41 _owns_stream(false)
42{
43}
44
45/**
46 * The copy constructor does not copy ownership of the stream.
47 */
48INLINE void StreamReader::
49operator = (const StreamReader &copy) {
50 if (_owns_stream) {
51 delete _in;
52 }
53 _in = copy._in;
54 _owns_stream = false;
55}
56
57/**
58 *
59 */
60INLINE StreamReader::
61~StreamReader() {
62 if (_owns_stream) {
63 delete _in;
64 }
65}
66
67/**
68 * Returns the stream in use.
69 */
70INLINE std::istream *StreamReader::
71get_istream() const {
72 return _in;
73}
74
75/**
76 * Extracts a boolean value.
77 */
78INLINE bool StreamReader::
79get_bool() {
80 return (get_uint8() != 0);
81}
82
83/**
84 * Extracts a signed 8-bit integer.
85 */
86INLINE int8_t StreamReader::
87get_int8() {
88 return (int8_t)_in->get();
89}
90
91/**
92 * Extracts an unsigned 8-bit integer.
93 */
94INLINE uint8_t StreamReader::
95get_uint8() {
96 return (uint8_t)_in->get();
97}
98
99/**
100 * Extracts a signed 16-bit integer.
101 */
102INLINE int16_t StreamReader::
103get_int16() {
104 int16_t readval, retval;
105 _in->read((char *)&readval, sizeof(readval));
106 LittleEndian s(&readval, 0, sizeof(readval));
107 s.store_value(&retval, sizeof(retval));
108 return retval;
109}
110
111/**
112 * Extracts a signed 32-bit integer.
113 */
114INLINE int32_t StreamReader::
115get_int32() {
116 int32_t readval, retval;
117 _in->read((char *)&readval, sizeof(readval));
118 LittleEndian s(&readval, 0, sizeof(readval));
119 s.store_value(&retval, sizeof(retval));
120 return retval;
121}
122
123/**
124 * Extracts a signed 64-bit integer.
125 */
126INLINE int64_t StreamReader::
127get_int64() {
128 int64_t readval, retval;
129 _in->read((char *)&readval, sizeof(readval));
130 LittleEndian s(&readval, 0, sizeof(readval));
131 s.store_value(&retval, sizeof(retval));
132 return retval;
133}
134
135/**
136 * Extracts an unsigned 16-bit integer.
137 */
138INLINE uint16_t StreamReader::
139get_uint16() {
140 uint16_t readval, retval;
141 _in->read((char *)&readval, sizeof(readval));
142 LittleEndian s(&readval, 0, sizeof(readval));
143 s.store_value(&retval, sizeof(retval));
144 return retval;
145}
146
147/**
148 * Extracts an unsigned 32-bit integer.
149 */
150INLINE uint32_t StreamReader::
151get_uint32() {
152 uint32_t readval, retval;
153 _in->read((char *)&readval, sizeof(readval));
154 LittleEndian s(&readval, 0, sizeof(readval));
155 s.store_value(&retval, sizeof(retval));
156 return retval;
157}
158
159/**
160 * Extracts an unsigned 64-bit integer.
161 */
162INLINE uint64_t StreamReader::
163get_uint64() {
164 uint64_t readval, retval;
165 _in->read((char *)&readval, sizeof(readval));
166 LittleEndian s(&readval, 0, sizeof(readval));
167 s.store_value(&retval, sizeof(retval));
168 return retval;
169}
170
171/**
172 * Extracts a 32-bit single-precision floating-point number. Since this kind
173 * of float is not necessarily portable across different architectures,
174 * special care is required.
175 */
176INLINE float StreamReader::
177get_float32() {
178 // For now, we assume the float format is portable across all architectures
179 // we are concerned with. If we come across one that is different, we will
180 // have to convert.
181 nassertr(sizeof(float) == 4, 0.0f);
182
183 float readval, retval;
184 _in->read((char *)&readval, sizeof(readval));
185 LittleEndian s(&readval, 0, sizeof(readval));
186 s.store_value(&retval, sizeof(retval));
187 return retval;
188}
189
190/**
191 * Extracts a 64-bit floating-point number.
192 */
193INLINE PN_float64 StreamReader::
194get_float64() {
195 PN_float64 readval, retval;
196 _in->read((char *)&readval, sizeof(readval));
197 LittleEndian s(&readval, 0, sizeof(readval));
198 s.store_value(&retval, sizeof(retval));
199 return retval;
200}
201
202/**
203 * Extracts a signed big-endian 16-bit integer.
204 */
205INLINE int16_t StreamReader::
206get_be_int16() {
207 int16_t readval, retval;
208 _in->read((char *)&readval, sizeof(readval));
209 BigEndian s(&readval, 0, sizeof(readval));
210 s.store_value(&retval, sizeof(retval));
211 return retval;
212}
213
214/**
215 * Extracts a signed big-endian 32-bit integer.
216 */
217INLINE int32_t StreamReader::
218get_be_int32() {
219 int32_t readval, retval;
220 _in->read((char *)&readval, sizeof(readval));
221 BigEndian s(&readval, 0, sizeof(readval));
222 s.store_value(&retval, sizeof(retval));
223 return retval;
224}
225
226/**
227 * Extracts a signed big-endian 64-bit integer.
228 */
229INLINE int64_t StreamReader::
230get_be_int64() {
231 int64_t readval, retval;
232 _in->read((char *)&readval, sizeof(readval));
233 BigEndian s(&readval, 0, sizeof(readval));
234 s.store_value(&retval, sizeof(retval));
235 return retval;
236}
237
238/**
239 * Extracts an unsigned big-endian 16-bit integer.
240 */
241INLINE uint16_t StreamReader::
243 uint16_t readval, retval;
244 _in->read((char *)&readval, sizeof(readval));
245 BigEndian s(&readval, 0, sizeof(readval));
246 s.store_value(&retval, sizeof(retval));
247 return retval;
248}
249
250/**
251 * Extracts an unsigned big-endian 32-bit integer.
252 */
253INLINE uint32_t StreamReader::
255 uint32_t readval, retval;
256 _in->read((char *)&readval, sizeof(readval));
257 BigEndian s(&readval, 0, sizeof(readval));
258 s.store_value(&retval, sizeof(retval));
259 return retval;
260}
261
262/**
263 * Extracts an unsigned big-endian 64-bit integer.
264 */
265INLINE uint64_t StreamReader::
267 uint64_t readval, retval;
268 _in->read((char *)&readval, sizeof(readval));
269 BigEndian s(&readval, 0, sizeof(readval));
270 s.store_value(&retval, sizeof(retval));
271 return retval;
272}
273
274/**
275 * Extracts a 32-bit single-precision big-endian floating-point number. Since
276 * this kind of float is not necessarily portable across different
277 * architectures, special care is required.
278 */
279INLINE float StreamReader::
281 // For now, we assume the float format is portable across all architectures
282 // we are concerned with. If we come across one that is different, we will
283 // have to convert.
284 nassertr(sizeof(float) == 4, 0.0f);
285
286 float readval, retval;
287 _in->read((char *)&readval, sizeof(readval));
288 BigEndian s(&readval, 0, sizeof(readval));
289 s.store_value(&retval, sizeof(retval));
290 return retval;
291}
292
293/**
294 * Extracts a 64-bit big-endian floating-point number.
295 */
296INLINE PN_float64 StreamReader::
298 PN_float64 readval, retval;
299 _in->read((char *)&readval, sizeof(readval));
300 BigEndian s(&readval, 0, sizeof(readval));
301 s.store_value(&retval, sizeof(retval));
302 return retval;
303}
NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatical...
void store_value(void *dest, size_t length) const
Copies the data, with byte reversal if appropriate, into the indicated numeric variable,...
NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatical...
void store_value(void *dest, size_t length) const
Copies the data, with byte reversal if appropriate, into the indicated numeric variable,...
A class to read sequential binary data directly from an istream.
uint8_t get_uint8()
Extracts an unsigned 8-bit integer.
int32_t get_be_int32()
Extracts a signed big-endian 32-bit integer.
uint16_t get_uint16()
Extracts an unsigned 16-bit integer.
int16_t get_int16()
Extracts a signed 16-bit integer.
float get_float32()
Extracts a 32-bit single-precision floating-point number.
bool get_bool()
Extracts a boolean value.
uint16_t get_be_uint16()
Extracts an unsigned big-endian 16-bit integer.
int64_t get_be_int64()
Extracts a signed big-endian 64-bit integer.
int8_t get_int8()
Extracts a signed 8-bit integer.
uint64_t get_uint64()
Extracts an unsigned 64-bit integer.
PN_float64 get_float64()
Extracts a 64-bit floating-point number.
void operator=(const StreamReader &copy)
The copy constructor does not copy ownership of the stream.
int32_t get_int32()
Extracts a signed 32-bit integer.
int16_t get_be_int16()
Extracts a signed big-endian 16-bit integer.
uint64_t get_be_uint64()
Extracts an unsigned big-endian 64-bit integer.
PN_float64 get_be_float64()
Extracts a 64-bit big-endian floating-point number.
int64_t get_int64()
Extracts a signed 64-bit integer.
uint32_t get_uint32()
Extracts an unsigned 32-bit integer.
float get_be_float32()
Extracts a 32-bit single-precision big-endian floating-point number.
get_istream
Returns the stream in use.
uint32_t get_be_uint32()
Extracts an unsigned big-endian 32-bit integer.