byteio - littleendianreader.go
1 package byteio
2
3 // File automatically generated with ./gen.sh
4
5 import (
6 "io"
7 "math"
8 )
9
10 // LittleEndianReader wraps a io.Reader to provide methods
11 // to make it easier to Read fundamental types
12 type LittleEndianReader struct {
13 io.Reader
14 buffer [9]byte
15 }
16
17 // ReadBool Reads a boolean
18 func (e *LittleEndianReader) ReadBool() (bool, int, error) {
19 b, n, err := e.ReadUint8()
20 return b != 0, n, err
21 }
22
23 // ReadInt8 Reads a 8 bit int as a int8 using the underlying io.Reader
24 func (e *LittleEndianReader) ReadInt8() (int8, int, error) {
25 n, err := io.ReadFull(e.Reader, e.buffer[:1])
26 if err != nil {
27 return 0, n, err
28 }
29 return int8(e.buffer[0]), 1, nil
30 }
31
32 // ReadInt16 Reads a 16 bit int as a int16 using the underlying io.Reader
33 func (e *LittleEndianReader) ReadInt16() (int16, int, error) {
34 n, err := io.ReadFull(e.Reader, e.buffer[:2])
35 if err != nil {
36 return 0, n, err
37 }
38 return int16(uint16(e.buffer[0]) | uint16(e.buffer[1])<<8), 2, nil
39 }
40
41 // ReadInt24 Reads a 24 bit int as a int32 using the underlying io.Reader
42 func (e *LittleEndianReader) ReadInt24() (int32, int, error) {
43 n, err := io.ReadFull(e.Reader, e.buffer[:3])
44 if err != nil {
45 return 0, n, err
46 }
47 return int32(uint32(e.buffer[0]) | uint32(e.buffer[1])<<8 | uint32(e.buffer[2])<<16), 3, nil
48 }
49
50 // ReadInt32 Reads a 32 bit int as a int32 using the underlying io.Reader
51 func (e *LittleEndianReader) ReadInt32() (int32, int, error) {
52 n, err := io.ReadFull(e.Reader, e.buffer[:4])
53 if err != nil {
54 return 0, n, err
55 }
56 return int32(uint32(e.buffer[0]) | uint32(e.buffer[1])<<8 | uint32(e.buffer[2])<<16 | uint32(e.buffer[3])<<24), 4, nil
57 }
58
59 // ReadInt40 Reads a 40 bit int as a int64 using the underlying io.Reader
60 func (e *LittleEndianReader) ReadInt40() (int64, int, error) {
61 n, err := io.ReadFull(e.Reader, e.buffer[:5])
62 if err != nil {
63 return 0, n, err
64 }
65 return int64(uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32), 5, nil
66 }
67
68 // ReadInt48 Reads a 48 bit int as a int64 using the underlying io.Reader
69 func (e *LittleEndianReader) ReadInt48() (int64, int, error) {
70 n, err := io.ReadFull(e.Reader, e.buffer[:6])
71 if err != nil {
72 return 0, n, err
73 }
74 return int64(uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40), 6, nil
75 }
76
77 // ReadInt56 Reads a 56 bit int as a int64 using the underlying io.Reader
78 func (e *LittleEndianReader) ReadInt56() (int64, int, error) {
79 n, err := io.ReadFull(e.Reader, e.buffer[:7])
80 if err != nil {
81 return 0, n, err
82 }
83 return int64(uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40 | uint64(e.buffer[6])<<48), 7, nil
84 }
85
86 // ReadInt64 Reads a 64 bit int as a int64 using the underlying io.Reader
87 func (e *LittleEndianReader) ReadInt64() (int64, int, error) {
88 n, err := io.ReadFull(e.Reader, e.buffer[:8])
89 if err != nil {
90 return 0, n, err
91 }
92 return int64(uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40 | uint64(e.buffer[6])<<48 | uint64(e.buffer[7])<<56), 8, nil
93 }
94
95 // ReadUint8 Reads a 8 bit uint as a uint8 using the underlying io.Reader
96 func (e *LittleEndianReader) ReadUint8() (uint8, int, error) {
97 n, err := io.ReadFull(e.Reader, e.buffer[:1])
98 if err != nil {
99 return 0, n, err
100 }
101 return e.buffer[0], 1, nil
102 }
103
104 // ReadUint16 Reads a 16 bit uint as a uint16 using the underlying io.Reader
105 func (e *LittleEndianReader) ReadUint16() (uint16, int, error) {
106 n, err := io.ReadFull(e.Reader, e.buffer[:2])
107 if err != nil {
108 return 0, n, err
109 }
110 return uint16(e.buffer[0]) | uint16(e.buffer[1])<<8, 2, nil
111 }
112
113 // ReadUint24 Reads a 24 bit uint as a uint32 using the underlying io.Reader
114 func (e *LittleEndianReader) ReadUint24() (uint32, int, error) {
115 n, err := io.ReadFull(e.Reader, e.buffer[:3])
116 if err != nil {
117 return 0, n, err
118 }
119 return uint32(e.buffer[0]) | uint32(e.buffer[1])<<8 | uint32(e.buffer[2])<<16, 3, nil
120 }
121
122 // ReadUint32 Reads a 32 bit uint as a uint32 using the underlying io.Reader
123 func (e *LittleEndianReader) ReadUint32() (uint32, int, error) {
124 n, err := io.ReadFull(e.Reader, e.buffer[:4])
125 if err != nil {
126 return 0, n, err
127 }
128 return uint32(e.buffer[0]) | uint32(e.buffer[1])<<8 | uint32(e.buffer[2])<<16 | uint32(e.buffer[3])<<24, 4, nil
129 }
130
131 // ReadUint40 Reads a 40 bit uint as a uint64 using the underlying io.Reader
132 func (e *LittleEndianReader) ReadUint40() (uint64, int, error) {
133 n, err := io.ReadFull(e.Reader, e.buffer[:5])
134 if err != nil {
135 return 0, n, err
136 }
137 return uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32, 5, nil
138 }
139
140 // ReadUint48 Reads a 48 bit uint as a uint64 using the underlying io.Reader
141 func (e *LittleEndianReader) ReadUint48() (uint64, int, error) {
142 n, err := io.ReadFull(e.Reader, e.buffer[:6])
143 if err != nil {
144 return 0, n, err
145 }
146 return uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40, 6, nil
147 }
148
149 // ReadUint56 Reads a 56 bit uint as a uint64 using the underlying io.Reader
150 func (e *LittleEndianReader) ReadUint56() (uint64, int, error) {
151 n, err := io.ReadFull(e.Reader, e.buffer[:7])
152 if err != nil {
153 return 0, n, err
154 }
155 return uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40 | uint64(e.buffer[6])<<48, 7, nil
156 }
157
158 // ReadUint64 Reads a 64 bit uint as a uint64 using the underlying io.Reader
159 func (e *LittleEndianReader) ReadUint64() (uint64, int, error) {
160 n, err := io.ReadFull(e.Reader, e.buffer[:8])
161 if err != nil {
162 return 0, n, err
163 }
164 return uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40 | uint64(e.buffer[6])<<48 | uint64(e.buffer[7])<<56, 8, nil
165 }
166
167 // ReadFloat32 Reads a 32 bit float as a float32 using the underlying io.Reader
168 func (e *LittleEndianReader) ReadFloat32() (float32, int, error) {
169 n, err := io.ReadFull(e.Reader, e.buffer[:4])
170 if err != nil {
171 return 0, n, err
172 }
173 return math.Float32frombits(uint32(e.buffer[0]) | uint32(e.buffer[1])<<8 | uint32(e.buffer[2])<<16 | uint32(e.buffer[3])<<24), 4, nil
174 }
175
176 // ReadFloat64 Reads a 64 bit float as a float64 using the underlying io.Reader
177 func (e *LittleEndianReader) ReadFloat64() (float64, int, error) {
178 n, err := io.ReadFull(e.Reader, e.buffer[:8])
179 if err != nil {
180 return 0, n, err
181 }
182 return math.Float64frombits(uint64(e.buffer[0]) | uint64(e.buffer[1])<<8 | uint64(e.buffer[2])<<16 | uint64(e.buffer[3])<<24 | uint64(e.buffer[4])<<32 | uint64(e.buffer[5])<<40 | uint64(e.buffer[6])<<48 | uint64(e.buffer[7])<<56), 8, nil
183 }
184
185 // ReadBytes Reads a []byte
186 func (e *LittleEndianReader) ReadBytes(size int) ([]byte, int, error) {
187 buf := make([]byte, size)
188 n, err := io.ReadFull(e, buf)
189 return buf[:n], n, err
190 }
191
192 // ReadBytesX Reads the length of the Bytes, using ReadUintX and then Reads the bytes
193 func (e *LittleEndianReader) ReadBytesX() ([]byte, int, error) {
194 size, n, err := e.ReadUintX()
195 if err != nil {
196 return nil, n, err
197 }
198 p, m, err := e.ReadBytes(int(size))
199 return p, n + m, err
200 }
201
202 // ReadBytes8 Reads the length of the Bytes, using ReadUint8 and then Reads the bytes
203 func (e *LittleEndianReader) ReadBytes8() ([]byte, int, error) {
204 size, n, err := e.ReadUint8()
205 if err != nil {
206 return nil, n, err
207 }
208 p, m, err := e.ReadBytes(int(size))
209 return p, n + m, err
210 }
211
212 // ReadBytes16 Reads the length of the Bytes, using ReadUint16 and then Reads the bytes
213 func (e *LittleEndianReader) ReadBytes16() ([]byte, int, error) {
214 size, n, err := e.ReadUint16()
215 if err != nil {
216 return nil, n, err
217 }
218 p, m, err := e.ReadBytes(int(size))
219 return p, n + m, err
220 }
221
222 // ReadBytes24 Reads the length of the Bytes, using ReadUint24 and then Reads the bytes
223 func (e *LittleEndianReader) ReadBytes24() ([]byte, int, error) {
224 size, n, err := e.ReadUint24()
225 if err != nil {
226 return nil, n, err
227 }
228 p, m, err := e.ReadBytes(int(size))
229 return p, n + m, err
230 }
231
232 // ReadBytes32 Reads the length of the Bytes, using ReadUint32 and then Reads the bytes
233 func (e *LittleEndianReader) ReadBytes32() ([]byte, int, error) {
234 size, n, err := e.ReadUint32()
235 if err != nil {
236 return nil, n, err
237 }
238 p, m, err := e.ReadBytes(int(size))
239 return p, n + m, err
240 }
241
242 // ReadBytes40 Reads the length of the Bytes, using ReadUint40 and then Reads the bytes
243 func (e *LittleEndianReader) ReadBytes40() ([]byte, int, error) {
244 size, n, err := e.ReadUint40()
245 if err != nil {
246 return nil, n, err
247 }
248 p, m, err := e.ReadBytes(int(size))
249 return p, n + m, err
250 }
251
252 // ReadBytes48 Reads the length of the Bytes, using ReadUint48 and then Reads the bytes
253 func (e *LittleEndianReader) ReadBytes48() ([]byte, int, error) {
254 size, n, err := e.ReadUint48()
255 if err != nil {
256 return nil, n, err
257 }
258 p, m, err := e.ReadBytes(int(size))
259 return p, n + m, err
260 }
261
262 // ReadBytes56 Reads the length of the Bytes, using ReadUint56 and then Reads the bytes
263 func (e *LittleEndianReader) ReadBytes56() ([]byte, int, error) {
264 size, n, err := e.ReadUint56()
265 if err != nil {
266 return nil, n, err
267 }
268 p, m, err := e.ReadBytes(int(size))
269 return p, n + m, err
270 }
271
272 // ReadBytes64 Reads the length of the Bytes, using ReadUint64 and then Reads the bytes
273 func (e *LittleEndianReader) ReadBytes64() ([]byte, int, error) {
274 size, n, err := e.ReadUint64()
275 if err != nil {
276 return nil, n, err
277 }
278 p, m, err := e.ReadBytes(int(size))
279 return p, n + m, err
280 }
281
282 // ReadString Reads a string
283 func (e *LittleEndianReader) ReadString(size int) (string, int, error) {
284 buf := make([]byte, size)
285 n, err := io.ReadFull(e, buf)
286 return string(buf[:n]), n, err
287 }
288
289 // ReadStringX Reads the length of the String, using ReadUintX and then Reads the bytes
290 func (e *LittleEndianReader) ReadStringX() (string, int, error) {
291 size, n, err := e.ReadUintX()
292 if err != nil {
293 return "", n, err
294 }
295 p, m, err := e.ReadString(int(size))
296 return p, n + m, err
297 }
298
299 // ReadString8 Reads the length of the String, using ReadUint8 and then Reads the bytes
300 func (e *LittleEndianReader) ReadString8() (string, int, error) {
301 size, n, err := e.ReadUint8()
302 if err != nil {
303 return "", n, err
304 }
305 p, m, err := e.ReadString(int(size))
306 return p, n + m, err
307 }
308
309 // ReadString16 Reads the length of the String, using ReadUint16 and then Reads the bytes
310 func (e *LittleEndianReader) ReadString16() (string, int, error) {
311 size, n, err := e.ReadUint16()
312 if err != nil {
313 return "", n, err
314 }
315 p, m, err := e.ReadString(int(size))
316 return p, n + m, err
317 }
318
319 // ReadString24 Reads the length of the String, using ReadUint24 and then Reads the bytes
320 func (e *LittleEndianReader) ReadString24() (string, int, error) {
321 size, n, err := e.ReadUint24()
322 if err != nil {
323 return "", n, err
324 }
325 p, m, err := e.ReadString(int(size))
326 return p, n + m, err
327 }
328
329 // ReadString32 Reads the length of the String, using ReadUint32 and then Reads the bytes
330 func (e *LittleEndianReader) ReadString32() (string, int, error) {
331 size, n, err := e.ReadUint32()
332 if err != nil {
333 return "", n, err
334 }
335 p, m, err := e.ReadString(int(size))
336 return p, n + m, err
337 }
338
339 // ReadString40 Reads the length of the String, using ReadUint40 and then Reads the bytes
340 func (e *LittleEndianReader) ReadString40() (string, int, error) {
341 size, n, err := e.ReadUint40()
342 if err != nil {
343 return "", n, err
344 }
345 p, m, err := e.ReadString(int(size))
346 return p, n + m, err
347 }
348
349 // ReadString48 Reads the length of the String, using ReadUint48 and then Reads the bytes
350 func (e *LittleEndianReader) ReadString48() (string, int, error) {
351 size, n, err := e.ReadUint48()
352 if err != nil {
353 return "", n, err
354 }
355 p, m, err := e.ReadString(int(size))
356 return p, n + m, err
357 }
358
359 // ReadString56 Reads the length of the String, using ReadUint56 and then Reads the bytes
360 func (e *LittleEndianReader) ReadString56() (string, int, error) {
361 size, n, err := e.ReadUint56()
362 if err != nil {
363 return "", n, err
364 }
365 p, m, err := e.ReadString(int(size))
366 return p, n + m, err
367 }
368
369 // ReadString64 Reads the length of the String, using ReadUint64 and then Reads the bytes
370 func (e *LittleEndianReader) ReadString64() (string, int, error) {
371 size, n, err := e.ReadUint64()
372 if err != nil {
373 return "", n, err
374 }
375 p, m, err := e.ReadString(int(size))
376 return p, n + m, err
377 }
378
379 // ReadString0 Reads the bytes of the string until a 0 byte is read
380 func (e *LittleEndianReader) ReadString0() (string, int, error) {
381 var (
382 n int
383 err error
384 d []byte
385 )
386 for {
387 var (
388 m int
389 p byte
390 )
391 p, m, err = e.ReadUint8()
392 n += m
393 if err != nil || p == 0 {
394 break
395 }
396 d = append(d, p)
397 }
398 return string(d), n, err
399 }
400