byteio - littleendianwriter.go
1 package byteio
2
3 // File automatically generated with ./gen.sh
4
5 import (
6 "io"
7 "math"
8 )
9
10 // LittleEndianWriter wraps a io.Writer to provide methods
11 // to make it easier to Write fundamental types
12 type LittleEndianWriter struct {
13 io.Writer
14 buffer [9]byte
15 }
16
17 // WriteBool Writes a boolean
18 func (e *LittleEndianWriter) WriteBool(b bool) (int, error) {
19 if b {
20 return e.WriteUint8(1)
21 } else {
22 return e.WriteUint8(0)
23 }
24 }
25
26 // WriteInt8 Writes a 8 bit int as a int8 using the underlying io.Writer
27 func (e *LittleEndianWriter) WriteInt8(d int8) (int, error) {
28 e.buffer[0] = byte(d)
29 return e.Writer.Write(e.buffer[:1])
30 }
31
32 // WriteInt16 Writes a 16 bit int as a int16 using the underlying io.Writer
33 func (e *LittleEndianWriter) WriteInt16(d int16) (int, error) {
34 c := uint16(d)
35 e.buffer = [9]byte{
36 byte(c),
37 byte(c >> 8),
38 }
39 return e.Writer.Write(e.buffer[:2])
40 }
41
42 // WriteInt24 Writes a 24 bit int as a int32 using the underlying io.Writer
43 func (e *LittleEndianWriter) WriteInt24(d int32) (int, error) {
44 c := uint32(d)
45 e.buffer = [9]byte{
46 byte(c),
47 byte(c >> 8),
48 byte(c >> 16),
49 }
50 return e.Writer.Write(e.buffer[:3])
51 }
52
53 // WriteInt32 Writes a 32 bit int as a int32 using the underlying io.Writer
54 func (e *LittleEndianWriter) WriteInt32(d int32) (int, error) {
55 c := uint32(d)
56 e.buffer = [9]byte{
57 byte(c),
58 byte(c >> 8),
59 byte(c >> 16),
60 byte(c >> 24),
61 }
62 return e.Writer.Write(e.buffer[:4])
63 }
64
65 // WriteInt40 Writes a 40 bit int as a int64 using the underlying io.Writer
66 func (e *LittleEndianWriter) WriteInt40(d int64) (int, error) {
67 c := uint64(d)
68 e.buffer = [9]byte{
69 byte(c),
70 byte(c >> 8),
71 byte(c >> 16),
72 byte(c >> 24),
73 byte(c >> 32),
74 }
75 return e.Writer.Write(e.buffer[:5])
76 }
77
78 // WriteInt48 Writes a 48 bit int as a int64 using the underlying io.Writer
79 func (e *LittleEndianWriter) WriteInt48(d int64) (int, error) {
80 c := uint64(d)
81 e.buffer = [9]byte{
82 byte(c),
83 byte(c >> 8),
84 byte(c >> 16),
85 byte(c >> 24),
86 byte(c >> 32),
87 byte(c >> 40),
88 }
89 return e.Writer.Write(e.buffer[:6])
90 }
91
92 // WriteInt56 Writes a 56 bit int as a int64 using the underlying io.Writer
93 func (e *LittleEndianWriter) WriteInt56(d int64) (int, error) {
94 c := uint64(d)
95 e.buffer = [9]byte{
96 byte(c),
97 byte(c >> 8),
98 byte(c >> 16),
99 byte(c >> 24),
100 byte(c >> 32),
101 byte(c >> 40),
102 byte(c >> 48),
103 }
104 return e.Writer.Write(e.buffer[:7])
105 }
106
107 // WriteInt64 Writes a 64 bit int as a int64 using the underlying io.Writer
108 func (e *LittleEndianWriter) WriteInt64(d int64) (int, error) {
109 c := uint64(d)
110 e.buffer = [9]byte{
111 byte(c),
112 byte(c >> 8),
113 byte(c >> 16),
114 byte(c >> 24),
115 byte(c >> 32),
116 byte(c >> 40),
117 byte(c >> 48),
118 byte(c >> 56),
119 }
120 return e.Writer.Write(e.buffer[:8])
121 }
122
123 // WriteUint8 Writes a 8 bit uint as a uint8 using the underlying io.Writer
124 func (e *LittleEndianWriter) WriteUint8(d uint8) (int, error) {
125 e.buffer[0] = d
126 return e.Writer.Write(e.buffer[:1])
127 }
128
129 // WriteUint16 Writes a 16 bit uint as a uint16 using the underlying io.Writer
130 func (e *LittleEndianWriter) WriteUint16(d uint16) (int, error) {
131 e.buffer = [9]byte{
132 byte(d),
133 byte(d >> 8),
134 }
135 return e.Writer.Write(e.buffer[:2])
136 }
137
138 // WriteUint24 Writes a 24 bit uint as a uint32 using the underlying io.Writer
139 func (e *LittleEndianWriter) WriteUint24(d uint32) (int, error) {
140 e.buffer = [9]byte{
141 byte(d),
142 byte(d >> 8),
143 byte(d >> 16),
144 }
145 return e.Writer.Write(e.buffer[:3])
146 }
147
148 // WriteUint32 Writes a 32 bit uint as a uint32 using the underlying io.Writer
149 func (e *LittleEndianWriter) WriteUint32(d uint32) (int, error) {
150 e.buffer = [9]byte{
151 byte(d),
152 byte(d >> 8),
153 byte(d >> 16),
154 byte(d >> 24),
155 }
156 return e.Writer.Write(e.buffer[:4])
157 }
158
159 // WriteUint40 Writes a 40 bit uint as a uint64 using the underlying io.Writer
160 func (e *LittleEndianWriter) WriteUint40(d uint64) (int, error) {
161 e.buffer = [9]byte{
162 byte(d),
163 byte(d >> 8),
164 byte(d >> 16),
165 byte(d >> 24),
166 byte(d >> 32),
167 }
168 return e.Writer.Write(e.buffer[:5])
169 }
170
171 // WriteUint48 Writes a 48 bit uint as a uint64 using the underlying io.Writer
172 func (e *LittleEndianWriter) WriteUint48(d uint64) (int, error) {
173 e.buffer = [9]byte{
174 byte(d),
175 byte(d >> 8),
176 byte(d >> 16),
177 byte(d >> 24),
178 byte(d >> 32),
179 byte(d >> 40),
180 }
181 return e.Writer.Write(e.buffer[:6])
182 }
183
184 // WriteUint56 Writes a 56 bit uint as a uint64 using the underlying io.Writer
185 func (e *LittleEndianWriter) WriteUint56(d uint64) (int, error) {
186 e.buffer = [9]byte{
187 byte(d),
188 byte(d >> 8),
189 byte(d >> 16),
190 byte(d >> 24),
191 byte(d >> 32),
192 byte(d >> 40),
193 byte(d >> 48),
194 }
195 return e.Writer.Write(e.buffer[:7])
196 }
197
198 // WriteUint64 Writes a 64 bit uint as a uint64 using the underlying io.Writer
199 func (e *LittleEndianWriter) WriteUint64(d uint64) (int, error) {
200 e.buffer = [9]byte{
201 byte(d),
202 byte(d >> 8),
203 byte(d >> 16),
204 byte(d >> 24),
205 byte(d >> 32),
206 byte(d >> 40),
207 byte(d >> 48),
208 byte(d >> 56),
209 }
210 return e.Writer.Write(e.buffer[:8])
211 }
212
213 // WriteFloat32 Writes a 32 bit float as a float32 using the underlying io.Writer
214 func (e *LittleEndianWriter) WriteFloat32(d float32) (int, error) {
215 c := math.Float32bits(d)
216 e.buffer = [9]byte{
217 byte(c),
218 byte(c >> 8),
219 byte(c >> 16),
220 byte(c >> 24),
221 }
222 return e.Writer.Write(e.buffer[:4])
223 }
224
225 // WriteFloat64 Writes a 64 bit float as a float64 using the underlying io.Writer
226 func (e *LittleEndianWriter) WriteFloat64(d float64) (int, error) {
227 c := math.Float64bits(d)
228 e.buffer = [9]byte{
229 byte(c),
230 byte(c >> 8),
231 byte(c >> 16),
232 byte(c >> 24),
233 byte(c >> 32),
234 byte(c >> 40),
235 byte(c >> 48),
236 byte(c >> 56),
237 }
238 return e.Writer.Write(e.buffer[:8])
239 }
240
241 // WriteBytesX Writes the length of the Bytes, using ReadUintX and then Writes the bytes
242 func (e *LittleEndianWriter) WriteBytesX(p []byte) (int, error) {
243 n, err := e.WriteUintX(uint64(len(p)))
244 if err != nil {
245 return n, err
246 }
247 m, err := e.Write(p)
248 return n + m, err
249 }
250
251 // WriteBytes8 Writes the length of the Bytes, using ReadUint8 and then Writes the bytes
252 func (e *LittleEndianWriter) WriteBytes8(p []byte) (int, error) {
253 n, err := e.WriteUint8(uint8(len(p)))
254 if err != nil {
255 return n, err
256 }
257 m, err := e.Write(p)
258 return n + m, err
259 }
260
261 // WriteBytes16 Writes the length of the Bytes, using ReadUint16 and then Writes the bytes
262 func (e *LittleEndianWriter) WriteBytes16(p []byte) (int, error) {
263 n, err := e.WriteUint16(uint16(len(p)))
264 if err != nil {
265 return n, err
266 }
267 m, err := e.Write(p)
268 return n + m, err
269 }
270
271 // WriteBytes24 Writes the length of the Bytes, using ReadUint24 and then Writes the bytes
272 func (e *LittleEndianWriter) WriteBytes24(p []byte) (int, error) {
273 n, err := e.WriteUint24(uint32(len(p)))
274 if err != nil {
275 return n, err
276 }
277 m, err := e.Write(p)
278 return n + m, err
279 }
280
281 // WriteBytes32 Writes the length of the Bytes, using ReadUint32 and then Writes the bytes
282 func (e *LittleEndianWriter) WriteBytes32(p []byte) (int, error) {
283 n, err := e.WriteUint32(uint32(len(p)))
284 if err != nil {
285 return n, err
286 }
287 m, err := e.Write(p)
288 return n + m, err
289 }
290
291 // WriteBytes40 Writes the length of the Bytes, using ReadUint40 and then Writes the bytes
292 func (e *LittleEndianWriter) WriteBytes40(p []byte) (int, error) {
293 n, err := e.WriteUint40(uint64(len(p)))
294 if err != nil {
295 return n, err
296 }
297 m, err := e.Write(p)
298 return n + m, err
299 }
300
301 // WriteBytes48 Writes the length of the Bytes, using ReadUint48 and then Writes the bytes
302 func (e *LittleEndianWriter) WriteBytes48(p []byte) (int, error) {
303 n, err := e.WriteUint48(uint64(len(p)))
304 if err != nil {
305 return n, err
306 }
307 m, err := e.Write(p)
308 return n + m, err
309 }
310
311 // WriteBytes56 Writes the length of the Bytes, using ReadUint56 and then Writes the bytes
312 func (e *LittleEndianWriter) WriteBytes56(p []byte) (int, error) {
313 n, err := e.WriteUint56(uint64(len(p)))
314 if err != nil {
315 return n, err
316 }
317 m, err := e.Write(p)
318 return n + m, err
319 }
320
321 // WriteBytes64 Writes the length of the Bytes, using ReadUint64 and then Writes the bytes
322 func (e *LittleEndianWriter) WriteBytes64(p []byte) (int, error) {
323 n, err := e.WriteUint64(uint64(len(p)))
324 if err != nil {
325 return n, err
326 }
327 m, err := e.Write(p)
328 return n + m, err
329 }
330
331 // WriteString Writes a string
332 func (e *LittleEndianWriter) WriteString(d string) (int, error) {
333 return io.WriteString(e.Writer, d)
334 }
335
336 // WriteStringX Writes the length of the String, using ReadUintX and then Writes the bytes
337 func (e *LittleEndianWriter) WriteStringX(p string) (int, error) {
338 n, err := e.WriteUintX(uint64(len(p)))
339 if err != nil {
340 return n, err
341 }
342 m, err := e.WriteString(p)
343 return n + m, err
344 }
345
346 // WriteString8 Writes the length of the String, using ReadUint8 and then Writes the bytes
347 func (e *LittleEndianWriter) WriteString8(p string) (int, error) {
348 n, err := e.WriteUint8(uint8(len(p)))
349 if err != nil {
350 return n, err
351 }
352 m, err := e.WriteString(p)
353 return n + m, err
354 }
355
356 // WriteString16 Writes the length of the String, using ReadUint16 and then Writes the bytes
357 func (e *LittleEndianWriter) WriteString16(p string) (int, error) {
358 n, err := e.WriteUint16(uint16(len(p)))
359 if err != nil {
360 return n, err
361 }
362 m, err := e.WriteString(p)
363 return n + m, err
364 }
365
366 // WriteString24 Writes the length of the String, using ReadUint24 and then Writes the bytes
367 func (e *LittleEndianWriter) WriteString24(p string) (int, error) {
368 n, err := e.WriteUint24(uint32(len(p)))
369 if err != nil {
370 return n, err
371 }
372 m, err := e.WriteString(p)
373 return n + m, err
374 }
375
376 // WriteString32 Writes the length of the String, using ReadUint32 and then Writes the bytes
377 func (e *LittleEndianWriter) WriteString32(p string) (int, error) {
378 n, err := e.WriteUint32(uint32(len(p)))
379 if err != nil {
380 return n, err
381 }
382 m, err := e.WriteString(p)
383 return n + m, err
384 }
385
386 // WriteString40 Writes the length of the String, using ReadUint40 and then Writes the bytes
387 func (e *LittleEndianWriter) WriteString40(p string) (int, error) {
388 n, err := e.WriteUint40(uint64(len(p)))
389 if err != nil {
390 return n, err
391 }
392 m, err := e.WriteString(p)
393 return n + m, err
394 }
395
396 // WriteString48 Writes the length of the String, using ReadUint48 and then Writes the bytes
397 func (e *LittleEndianWriter) WriteString48(p string) (int, error) {
398 n, err := e.WriteUint48(uint64(len(p)))
399 if err != nil {
400 return n, err
401 }
402 m, err := e.WriteString(p)
403 return n + m, err
404 }
405
406 // WriteString56 Writes the length of the String, using ReadUint56 and then Writes the bytes
407 func (e *LittleEndianWriter) WriteString56(p string) (int, error) {
408 n, err := e.WriteUint56(uint64(len(p)))
409 if err != nil {
410 return n, err
411 }
412 m, err := e.WriteString(p)
413 return n + m, err
414 }
415
416 // WriteString64 Writes the length of the String, using ReadUint64 and then Writes the bytes
417 func (e *LittleEndianWriter) WriteString64(p string) (int, error) {
418 n, err := e.WriteUint64(uint64(len(p)))
419 if err != nil {
420 return n, err
421 }
422 m, err := e.WriteString(p)
423 return n + m, err
424 }
425
426 // WriteString0 Writes the bytes of the string ending with a 0 byte
427 func (e *LittleEndianWriter) WriteString0(p string) (int, error) {
428 n, err := e.WriteString(p)
429 if err == nil {
430 var m int
431 m, err = e.WriteUint8(0)
432 n += m
433 }
434 return n, err
435 }
436