Panda3D
 All Classes Functions Variables Enumerations
streamReader.I
1 // Filename: streamReader.I
2 // Created by: drose (04Aug02)
3 //
4 ////////////////////////////////////////////////////////////////////
5 //
6 // PANDA 3D SOFTWARE
7 // Copyright (c) Carnegie Mellon University. All rights reserved.
8 //
9 // All use of this software is subject to the terms of the revised BSD
10 // license. You should have received a copy of this license along
11 // with this source code in a file named "LICENSE."
12 //
13 ////////////////////////////////////////////////////////////////////
14 
15 
16 ////////////////////////////////////////////////////////////////////
17 // Function: StreamReader::Constructor
18 // Access: Public
19 // Description:
20 ////////////////////////////////////////////////////////////////////
21 INLINE StreamReader::
22 StreamReader(istream &in) :
23  _in(&in),
24  _owns_stream(false)
25 {
26 }
27 
28 ////////////////////////////////////////////////////////////////////
29 // Function: StreamReader::Constructor
30 // Access: Published
31 // Description: If owns_stream is true, the stream pointer will be
32 // deleted when the StreamReader destructs.
33 ////////////////////////////////////////////////////////////////////
34 INLINE StreamReader::
35 StreamReader(istream *in, bool owns_stream) :
36  _in(in),
37  _owns_stream(owns_stream)
38 {
39 }
40 
41 ////////////////////////////////////////////////////////////////////
42 // Function: StreamReader::Copy Constructor
43 // Access: Published
44 // Description: The copy constructor does not copy ownership of the
45 // stream.
46 ////////////////////////////////////////////////////////////////////
47 INLINE StreamReader::
48 StreamReader(const StreamReader &copy) :
49  _in(copy._in),
50  _owns_stream(false)
51 {
52 }
53 
54 ////////////////////////////////////////////////////////////////////
55 // Function: StreamReader::Copy Assignment Operator
56 // Access: Published
57 // Description: The copy constructor does not copy ownership of the
58 // stream.
59 ////////////////////////////////////////////////////////////////////
60 INLINE void StreamReader::
61 operator = (const StreamReader &copy) {
62  if (_owns_stream) {
63  delete _in;
64  }
65  _in = copy._in;
66  _owns_stream = false;
67 }
68 
69 ////////////////////////////////////////////////////////////////////
70 // Function: StreamReader::Destructor
71 // Access: Published
72 // Description:
73 ////////////////////////////////////////////////////////////////////
74 INLINE StreamReader::
75 ~StreamReader() {
76  if (_owns_stream) {
77  delete _in;
78  }
79 }
80 
81 ////////////////////////////////////////////////////////////////////
82 // Function: StreamReader::get_istream
83 // Access: Published
84 // Description: Returns the stream in use.
85 ////////////////////////////////////////////////////////////////////
86 INLINE istream *StreamReader::
87 get_istream() const {
88  return _in;
89 }
90 
91 ////////////////////////////////////////////////////////////////////
92 // Function: StreamReader::get_bool
93 // Access: Published
94 // Description: Extracts a boolean value.
95 ////////////////////////////////////////////////////////////////////
96 INLINE bool StreamReader::
98  return (get_uint8() != 0);
99 }
100 
101 ////////////////////////////////////////////////////////////////////
102 // Function: StreamReader::get_int8
103 // Access: Published
104 // Description: Extracts a signed 8-bit integer.
105 ////////////////////////////////////////////////////////////////////
106 INLINE PN_int8 StreamReader::
108  return (PN_int8)_in->get();
109 }
110 
111 ////////////////////////////////////////////////////////////////////
112 // Function: StreamReader::get_uint8
113 // Access: Published
114 // Description: Extracts an unsigned 8-bit integer.
115 ////////////////////////////////////////////////////////////////////
116 INLINE PN_uint8 StreamReader::
118  return (PN_uint8)_in->get();
119 }
120 
121 ////////////////////////////////////////////////////////////////////
122 // Function: StreamReader::get_int16
123 // Access: Published
124 // Description: Extracts a signed 16-bit integer.
125 ////////////////////////////////////////////////////////////////////
126 INLINE PN_int16 StreamReader::
128  PN_int16 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 // Function: StreamReader::get_int32
137 // Access: Published
138 // Description: Extracts a signed 32-bit integer.
139 ////////////////////////////////////////////////////////////////////
140 INLINE PN_int32 StreamReader::
142  PN_int32 readval, retval;
143  _in->read((char *)&readval, sizeof(readval));
144  LittleEndian s(&readval, 0, sizeof(readval));
145  s.store_value(&retval, sizeof(retval));
146  return retval;
147 }
148 
149 ////////////////////////////////////////////////////////////////////
150 // Function: StreamReader::get_int64
151 // Access: Published
152 // Description: Extracts a signed 64-bit integer.
153 ////////////////////////////////////////////////////////////////////
154 INLINE PN_int64 StreamReader::
156  PN_int64 readval, retval;
157  _in->read((char *)&readval, sizeof(readval));
158  LittleEndian s(&readval, 0, sizeof(readval));
159  s.store_value(&retval, sizeof(retval));
160  return retval;
161 }
162 
163 ////////////////////////////////////////////////////////////////////
164 // Function: StreamReader::get_uint16
165 // Access: Published
166 // Description: Extracts an unsigned 16-bit integer.
167 ////////////////////////////////////////////////////////////////////
168 INLINE PN_uint16 StreamReader::
170  PN_uint16 readval, retval;
171  _in->read((char *)&readval, sizeof(readval));
172  LittleEndian s(&readval, 0, sizeof(readval));
173  s.store_value(&retval, sizeof(retval));
174  return retval;
175 }
176 
177 ////////////////////////////////////////////////////////////////////
178 // Function: StreamReader::get_uint32
179 // Access: Published
180 // Description: Extracts an unsigned 32-bit integer.
181 ////////////////////////////////////////////////////////////////////
182 INLINE PN_uint32 StreamReader::
184  PN_uint32 readval, retval;
185  _in->read((char *)&readval, sizeof(readval));
186  LittleEndian s(&readval, 0, sizeof(readval));
187  s.store_value(&retval, sizeof(retval));
188  return retval;
189 }
190 
191 ////////////////////////////////////////////////////////////////////
192 // Function: StreamReader::get_uint64
193 // Access: Published
194 // Description: Extracts an unsigned 64-bit integer.
195 ////////////////////////////////////////////////////////////////////
196 INLINE PN_uint64 StreamReader::
198  PN_uint64 readval, retval;
199  _in->read((char *)&readval, sizeof(readval));
200  LittleEndian s(&readval, 0, sizeof(readval));
201  s.store_value(&retval, sizeof(retval));
202  return retval;
203 }
204 
205 ////////////////////////////////////////////////////////////////////
206 // Function: StreamReader::get_float32
207 // Access: Published
208 // Description: Extracts a 32-bit single-precision floating-point
209 // number. Since this kind of float is not necessarily
210 // portable across different architectures, special care
211 // is required.
212 ////////////////////////////////////////////////////////////////////
213 INLINE float StreamReader::
215  // For now, we assume the float format is portable across all
216  // architectures we are concerned with. If we come across one that
217  // is different, we will have to convert.
218  nassertr(sizeof(float) == 4, 0.0f);
219 
220  float readval, retval;
221  _in->read((char *)&readval, sizeof(readval));
222  LittleEndian s(&readval, 0, sizeof(readval));
223  s.store_value(&retval, sizeof(retval));
224  return retval;
225 }
226 
227 ////////////////////////////////////////////////////////////////////
228 // Function: StreamReader::get_float64
229 // Access: Published
230 // Description: Extracts a 64-bit floating-point number.
231 ////////////////////////////////////////////////////////////////////
232 INLINE PN_float64 StreamReader::
234  PN_float64 readval, retval;
235  _in->read((char *)&readval, sizeof(readval));
236  LittleEndian s(&readval, 0, sizeof(readval));
237  s.store_value(&retval, sizeof(retval));
238  return retval;
239 }
240 
241 ////////////////////////////////////////////////////////////////////
242 // Function: StreamReader::get_be_int16
243 // Access: Published
244 // Description: Extracts a signed big-endian 16-bit integer.
245 ////////////////////////////////////////////////////////////////////
246 INLINE PN_int16 StreamReader::
248  PN_int16 readval, retval;
249  _in->read((char *)&readval, sizeof(readval));
250  BigEndian s(&readval, 0, sizeof(readval));
251  s.store_value(&retval, sizeof(retval));
252  return retval;
253 }
254 
255 ////////////////////////////////////////////////////////////////////
256 // Function: StreamReader::get_be_int32
257 // Access: Published
258 // Description: Extracts a signed big-endian 32-bit integer.
259 ////////////////////////////////////////////////////////////////////
260 INLINE PN_int32 StreamReader::
262  PN_int32 readval, retval;
263  _in->read((char *)&readval, sizeof(readval));
264  BigEndian s(&readval, 0, sizeof(readval));
265  s.store_value(&retval, sizeof(retval));
266  return retval;
267 }
268 
269 ////////////////////////////////////////////////////////////////////
270 // Function: StreamReader::get_be_int64
271 // Access: Published
272 // Description: Extracts a signed big-endian 64-bit integer.
273 ////////////////////////////////////////////////////////////////////
274 INLINE PN_int64 StreamReader::
276  PN_int64 readval, retval;
277  _in->read((char *)&readval, sizeof(readval));
278  BigEndian s(&readval, 0, sizeof(readval));
279  s.store_value(&retval, sizeof(retval));
280  return retval;
281 }
282 
283 ////////////////////////////////////////////////////////////////////
284 // Function: StreamReader::get_be_uint16
285 // Access: Published
286 // Description: Extracts an unsigned big-endian 16-bit integer.
287 ////////////////////////////////////////////////////////////////////
288 INLINE PN_uint16 StreamReader::
290  PN_uint16 readval, retval;
291  _in->read((char *)&readval, sizeof(readval));
292  BigEndian s(&readval, 0, sizeof(readval));
293  s.store_value(&retval, sizeof(retval));
294  return retval;
295 }
296 
297 ////////////////////////////////////////////////////////////////////
298 // Function: StreamReader::get_be_uint32
299 // Access: Published
300 // Description: Extracts an unsigned big-endian 32-bit integer.
301 ////////////////////////////////////////////////////////////////////
302 INLINE PN_uint32 StreamReader::
304  PN_uint32 readval, retval;
305  _in->read((char *)&readval, sizeof(readval));
306  BigEndian s(&readval, 0, sizeof(readval));
307  s.store_value(&retval, sizeof(retval));
308  return retval;
309 }
310 
311 ////////////////////////////////////////////////////////////////////
312 // Function: StreamReader::get_be_uint64
313 // Access: Published
314 // Description: Extracts an unsigned big-endian 64-bit integer.
315 ////////////////////////////////////////////////////////////////////
316 INLINE PN_uint64 StreamReader::
318  PN_uint64 readval, retval;
319  _in->read((char *)&readval, sizeof(readval));
320  BigEndian s(&readval, 0, sizeof(readval));
321  s.store_value(&retval, sizeof(retval));
322  return retval;
323 }
324 
325 ////////////////////////////////////////////////////////////////////
326 // Function: StreamReader::get_be_float32
327 // Access: Published
328 // Description: Extracts a 32-bit single-precision big-endian
329 // floating-point number. Since this kind of float is
330 // not necessarily portable across different
331 // architectures, special care is required.
332 ////////////////////////////////////////////////////////////////////
333 INLINE float StreamReader::
335  // For now, we assume the float format is portable across all
336  // architectures we are concerned with. If we come across one that
337  // is different, we will have to convert.
338  nassertr(sizeof(float) == 4, 0.0f);
339 
340  float readval, retval;
341  _in->read((char *)&readval, sizeof(readval));
342  BigEndian s(&readval, 0, sizeof(readval));
343  s.store_value(&retval, sizeof(retval));
344  return retval;
345 }
346 
347 ////////////////////////////////////////////////////////////////////
348 // Function: StreamReader::get_be_float64
349 // Access: Published
350 // Description: Extracts a 64-bit big-endian floating-point number.
351 ////////////////////////////////////////////////////////////////////
352 INLINE PN_float64 StreamReader::
354  PN_float64 readval, retval;
355  _in->read((char *)&readval, sizeof(readval));
356  BigEndian s(&readval, 0, sizeof(readval));
357  s.store_value(&retval, sizeof(retval));
358  return retval;
359 }
void store_value(void *dest, size_t length) const
Copies the data, with byte reversal if appropriate, into the indicated numeric variable, whose address and sizeof are given.
PN_int32 get_be_int32()
Extracts a signed big-endian 32-bit integer.
Definition: streamReader.I:261
istream * get_istream() const
Returns the stream in use.
Definition: streamReader.I:87
PN_uint32 get_uint32()
Extracts an unsigned 32-bit integer.
Definition: streamReader.I:183
PN_uint64 get_be_uint64()
Extracts an unsigned big-endian 64-bit integer.
Definition: streamReader.I:317
PN_float64 get_be_float64()
Extracts a 64-bit big-endian floating-point number.
Definition: streamReader.I:353
void store_value(void *dest, size_t length) const
Copies the data, with byte reversal if appropriate, into the indicated numeric variable, whose address and sizeof are given.
float get_be_float32()
Extracts a 32-bit single-precision big-endian floating-point number.
Definition: streamReader.I:334
PN_uint64 get_uint64()
Extracts an unsigned 64-bit integer.
Definition: streamReader.I:197
PN_int8 get_int8()
Extracts a signed 8-bit integer.
Definition: streamReader.I:107
PN_int16 get_be_int16()
Extracts a signed big-endian 16-bit integer.
Definition: streamReader.I:247
PN_uint16 get_be_uint16()
Extracts an unsigned big-endian 16-bit integer.
Definition: streamReader.I:289
NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatical...
PN_float64 get_float64()
Extracts a 64-bit floating-point number.
Definition: streamReader.I:233
float get_float32()
Extracts a 32-bit single-precision floating-point number.
Definition: streamReader.I:214
NativeNumericData and ReversedNumericData work together to provide a sneaky interface for automatical...
PN_int16 get_int16()
Extracts a signed 16-bit integer.
Definition: streamReader.I:127
PN_uint16 get_uint16()
Extracts an unsigned 16-bit integer.
Definition: streamReader.I:169
PN_uint8 get_uint8()
Extracts an unsigned 8-bit integer.
Definition: streamReader.I:117
PN_int32 get_int32()
Extracts a signed 32-bit integer.
Definition: streamReader.I:141
void operator=(const StreamReader &copy)
The copy constructor does not copy ownership of the stream.
Definition: streamReader.I:61
A class to read sequential binary data directly from an istream.
Definition: streamReader.h:30
PN_uint32 get_be_uint32()
Extracts an unsigned big-endian 32-bit integer.
Definition: streamReader.I:303
PN_int64 get_int64()
Extracts a signed 64-bit integer.
Definition: streamReader.I:155
bool get_bool()
Extracts a boolean value.
Definition: streamReader.I:97
PN_int64 get_be_int64()
Extracts a signed big-endian 64-bit integer.
Definition: streamReader.I:275