osrs_bytes/lib.rs
1//! A Rust library for working with the Oldschool Runescape data types.
2//!
3//! Data types in Oldschool Runescape are slightly different compared to normal types. Example of these types are the smart type, middle endian, and occassional switching to little endian. Therefore it has been seen as necessary to have traits that can work with these data types.
4//!
5//! This crate provides Read and Write extensions for working with the data types on any data structure implementing `&[u8]` such as Vec, Cursor etc.
6
7use std::io::{self, Error, ErrorKind, Read, Result, Write};
8
9pub trait ReadExt: Read {
10 /// Reads an unsigned byte
11 ///
12 /// # Examples
13 ///
14 /// ```rust
15 /// use std::io::Cursor;
16 /// use osrs_bytes::ReadExt;
17 ///
18 /// let mut rdr = Cursor::new(vec![2, 5]);
19 /// assert_eq!(rdr.read_u8().unwrap(), 2);
20 /// assert_eq!(rdr.read_u8().unwrap(), 5);
21 /// ```
22 #[inline]
23 fn read_u8(&mut self) -> Result<u8> {
24 let mut buf = [0; 1];
25 self.read_exact(&mut buf)?;
26 Ok(buf[0])
27 }
28
29 /// Reads an unsigned byte add
30 ///
31 /// # Examples
32 ///
33 /// ```rust
34 /// use std::io::Cursor;
35 /// use osrs_bytes::ReadExt;
36 ///
37 /// let mut rdr = Cursor::new(vec![125]);
38 /// assert_eq!(rdr.read_u8_add().unwrap(), 253)
39 /// ```
40 ///
41 /// ```rust
42 ///
43 /// use std::io::Cursor;
44 /// use osrs_bytes::ReadExt;
45 ///
46 /// let mut rdr = Cursor::new(vec![128]);
47 /// assert_eq!(rdr.read_u8_add().unwrap(), 0)
48 /// ```
49 #[inline]
50 fn read_u8_add(&mut self) -> Result<u8> {
51 Ok(self.read_u8()?.wrapping_sub(128))
52 }
53
54 /// Reads an unsigned byte negate
55 ///
56 /// # Examples
57 ///
58 /// ```rust
59 /// use std::io::Cursor;
60 /// use osrs_bytes::ReadExt;
61 ///
62 /// let mut rdr = Cursor::new(vec![128]);
63 /// assert_eq!(rdr.read_u8_neg().unwrap(), 128);
64 /// ```
65 ///
66 /// ```rust
67 /// use std::io::Cursor;
68 /// use osrs_bytes::ReadExt;
69 ///
70 /// let mut rdr = Cursor::new(vec![127]);
71 /// assert_eq!(rdr.read_u8_neg().unwrap(), 129);
72 /// ```
73 ///
74 /// ```rust
75 /// use std::io::Cursor;
76 /// use osrs_bytes::ReadExt;
77 ///
78 /// let mut rdr = Cursor::new(vec![0]);
79 /// assert_eq!(rdr.read_u8_neg().unwrap(), 0);
80 /// ```
81 #[inline]
82 fn read_u8_neg(&mut self) -> Result<u8> {
83 Ok(0u8.wrapping_sub(self.read_u8()?))
84 }
85
86 /// Reads an unsigned byte sub
87 ///
88 /// # Examples
89 ///
90 /// ```rust
91 /// use std::io::Cursor;
92 /// use osrs_bytes::ReadExt;
93 ///
94 /// let mut rdr = Cursor::new(vec![128]);
95 /// assert_eq!(rdr.read_u8_sub().unwrap(), 0);
96 /// ```
97 ///
98 /// ```rust
99 /// use std::io::Cursor;
100 /// use osrs_bytes::ReadExt;
101 ///
102 /// let mut rdr = Cursor::new(vec![127]);
103 /// assert_eq!(rdr.read_u8_sub().unwrap(), 1);
104 /// ```
105 ///
106 /// ```rust
107 /// use std::io::Cursor;
108 /// use osrs_bytes::ReadExt;
109 ///
110 /// let mut rdr = Cursor::new(vec![0]);
111 /// assert_eq!(rdr.read_u8_sub().unwrap(), 128);
112 /// ```
113 #[inline]
114 fn read_u8_sub(&mut self) -> Result<u8> {
115 Ok(128u8.wrapping_sub(self.read_u8()?))
116 }
117
118 /// Reads a signed byte
119 ///
120 /// # Examples
121 ///
122 /// ```rust
123 /// use std::io::Cursor;
124 /// use osrs_bytes::ReadExt;
125 ///
126 /// let mut rdr = Cursor::new(vec![248, 6]);
127 /// assert_eq!(rdr.read_i8().unwrap(), -8);
128 /// assert_eq!(rdr.read_i8().unwrap(), 6);
129 /// ```
130 #[inline]
131 fn read_i8(&mut self) -> Result<i8> {
132 Ok(self.read_u8()? as i8)
133 }
134
135 /// Reads a signed byte add
136 ///
137 /// # Examples
138 ///
139 /// ```rust
140 /// use std::io::Cursor;
141 /// use osrs_bytes::ReadExt;
142 ///
143 /// let mut rdr = Cursor::new(vec![125]);
144 /// assert_eq!(rdr.read_i8_add().unwrap(), -3);
145 /// ```
146 ///
147 /// ```rust
148 /// use std::io::Cursor;
149 /// use osrs_bytes::ReadExt;
150 ///
151 /// let mut rdr = Cursor::new(vec![128]);
152 /// assert_eq!(rdr.read_i8_add().unwrap(), 0);
153 /// ```
154 #[inline]
155 fn read_i8_add(&mut self) -> Result<i8> {
156 Ok(self.read_u8_add()? as i8)
157 }
158
159 /// Reads a signed byte negate
160 ///
161 /// # Examples
162 ///
163 /// ```rust
164 /// use std::io::Cursor;
165 /// use osrs_bytes::ReadExt;
166 ///
167 /// let mut rdr = Cursor::new(vec![128]);
168 /// assert_eq!(rdr.read_i8_neg().unwrap(), -128);
169 /// ```
170 ///
171 /// ```rust
172 /// use std::io::Cursor;
173 /// use osrs_bytes::ReadExt;
174 ///
175 /// let mut rdr = Cursor::new(vec![42]);
176 /// assert_eq!(rdr.read_i8_neg().unwrap(), -42);
177 /// ```
178 #[inline]
179 fn read_i8_neg(&mut self) -> Result<i8> {
180 Ok(self.read_u8_neg()? as i8)
181 }
182
183 /// Reads a signed byte sub
184 ///
185 /// # Examples
186 ///
187 /// ```rust
188 /// use std::io::Cursor;
189 /// use osrs_bytes::ReadExt;
190 ///
191 /// let mut rdr = Cursor::new(vec![128]);
192 /// assert_eq!(rdr.read_i8_sub().unwrap(), 0);
193 /// ```
194 ///
195 /// ```rust
196 /// use std::io::Cursor;
197 /// use osrs_bytes::ReadExt;
198 ///
199 /// let mut rdr = Cursor::new(vec![42]);
200 /// assert_eq!(rdr.read_i8_sub().unwrap(), 86);
201 /// ```
202 #[inline]
203 fn read_i8_sub(&mut self) -> Result<i8> {
204 Ok(self.read_u8_sub()? as i8)
205 }
206
207 /// Reads a bool
208 ///
209 /// # Examples
210 ///
211 /// ```rust
212 /// use std::io::Cursor;
213 /// use osrs_bytes::ReadExt;
214 ///
215 /// let mut rdr = Cursor::new(vec![0, 1, 2]);
216 /// assert_eq!(rdr.read_bool().unwrap(), false);
217 /// assert_eq!(rdr.read_bool().unwrap(), true);
218 /// assert_eq!(rdr.read_bool().unwrap(), true);
219 /// ```
220 #[inline]
221 fn read_bool(&mut self) -> Result<bool> {
222 let mut buf = [0; 1];
223 self.read_exact(&mut buf)?;
224 Ok(buf[0] != 0)
225 }
226
227 /// Reads an unsigned short as big endian
228 ///
229 /// # Examples
230 ///
231 /// ```rust
232 /// use std::io::Cursor;
233 /// use osrs_bytes::ReadExt;
234 ///
235 /// let mut rdr = Cursor::new(vec![66, 89]);
236 /// assert_eq!(rdr.read_u16().unwrap(), 16985);
237 /// ```
238 #[inline]
239 fn read_u16(&mut self) -> Result<u16> {
240 let mut buf = [0; 2];
241 self.read_exact(&mut buf)?;
242 Ok(u16::from_be_bytes(buf))
243 }
244
245 /// Reads an unsigned short as little endian
246 ///
247 /// # Examples
248 ///
249 /// ```rust
250 /// use std::io::Cursor;
251 /// use osrs_bytes::ReadExt;
252 ///
253 /// let mut rdr = Cursor::new(vec![89, 66]);
254 /// assert_eq!(rdr.read_u16_le().unwrap(), 16985);
255 /// ```
256 #[inline]
257 fn read_u16_le(&mut self) -> Result<u16> {
258 let mut buf = [0; 2];
259 self.read_exact(&mut buf)?;
260 Ok(u16::from_le_bytes(buf))
261 }
262
263 /// Reads an unsigned short as smart
264 ///
265 /// # Examples
266 ///
267 /// ```rust
268 /// use std::io::Cursor;
269 /// use osrs_bytes::ReadExt;
270 ///
271 /// let mut rdr = Cursor::new(vec![0]);
272 /// assert_eq!(rdr.read_u16_smart().unwrap(), 0);
273 /// ```
274 ///
275 /// ```rust
276 /// use std::io::Cursor;
277 /// use osrs_bytes::ReadExt;
278 ///
279 /// let mut rdr = Cursor::new(vec![0x40]);
280 /// assert_eq!(rdr.read_u16_smart().unwrap(), 0x40);
281 /// ```
282 ///
283 /// Example with a value less than 128. Here we can see that the first byte is returned.
284 ///
285 /// ```rust
286 /// use std::io::Cursor;
287 /// use osrs_bytes::ReadExt;
288 ///
289 /// let mut rdr = Cursor::new(vec![0x7F]);
290 /// assert_eq!(rdr.read_u16_smart().unwrap(), 0x7F);
291 /// ```
292 ///
293 /// Example where the first byte's value is 128 or greater.
294 /// 128 is the max value in a smart type.
295 ///
296 /// ```rust
297 /// use std::io::Cursor;
298 /// use osrs_bytes::ReadExt;
299 ///
300 /// let mut rdr = Cursor::new(vec![0x80, 0x80]);
301 /// assert_eq!(rdr.read_u16_smart().unwrap(), 0x80);
302 /// ```
303 ///
304 /// Example where the first byte's value is 128 or greater.
305 /// This returns it as a short.
306 ///
307 /// ```rust
308 /// use std::io::Cursor;
309 /// use osrs_bytes::ReadExt;
310 ///
311 /// let mut rdr = Cursor::new(vec![0xC0, 0x00]);
312 /// assert_eq!(rdr.read_u16_smart().unwrap(), 0x4000);
313 /// ```
314 ///
315 /// Example of the highest possible value for a smart type.
316 ///
317 /// ```rust
318 /// use std::io::Cursor;
319 /// use osrs_bytes::ReadExt;
320 ///
321 /// let mut rdr = Cursor::new(vec![0xFF, 0xFF]);
322 /// assert_eq!(rdr.read_u16_smart().unwrap(), 0x7FFF);
323 /// ```
324 #[inline]
325 fn read_u16_smart(&mut self) -> Result<u16> {
326 let peek = self.read_u8()?;
327 if peek & 128 == 0 {
328 Ok(peek as u16)
329 } else {
330 Ok(((peek as u16 & 0x7F) << 8) | (self.read_u8()? as u16))
331 }
332 }
333
334 /// Reads an unsigned short as big endian
335 ///
336 /// # Examples
337 ///
338 /// ```rust
339 /// use std::io::Cursor;
340 /// use osrs_bytes::ReadExt;
341 ///
342 /// let mut rdr = Cursor::new(vec![99, 130]);
343 /// assert_eq!(rdr.read_u16_add().unwrap(), 25346);
344 /// ```
345 #[inline]
346 fn read_u16_add(&mut self) -> Result<u16> {
347 Ok(((self.read_u8()? as u16) << 8) | ((self.read_u8()?.wrapping_sub(128)) as u16))
348 }
349
350 /// Reads an unsigned short add as little endian
351 ///
352 /// # Examples
353 ///
354 /// ```rust
355 /// use std::io::Cursor;
356 /// use osrs_bytes::ReadExt;
357 ///
358 /// let mut rdr = Cursor::new(vec![89, 66]);
359 /// assert_eq!(rdr.read_u16_add_le().unwrap(), 17113);
360 /// ```
361 #[inline]
362 fn read_u16_add_le(&mut self) -> Result<u16> {
363 Ok(((self.read_u8()?.wrapping_sub(128)) as u16) | ((self.read_u8()? as u16) << 8))
364 }
365
366 /// Reads a signed short as big endian
367 ///
368 /// # Examples
369 ///
370 /// ```rust
371 /// use std::io::Cursor;
372 /// use osrs_bytes::ReadExt;
373 ///
374 /// let mut rdr = Cursor::new(vec![255, 98]);
375 /// assert_eq!(rdr.read_i16().unwrap(), -158);
376 /// ```
377 #[inline]
378 fn read_i16(&mut self) -> Result<i16> {
379 Ok(self.read_u16()? as i16)
380 }
381
382 /// Reads a signed short as little endian
383 ///
384 /// # Examples
385 ///
386 /// ```rust
387 /// use std::io::Cursor;
388 /// use osrs_bytes::ReadExt;
389 ///
390 /// let mut rdr = Cursor::new(vec![98, 255]);
391 /// assert_eq!(rdr.read_i16_le().unwrap(), -158);
392 /// ```
393 #[inline]
394 fn read_i16_le(&mut self) -> Result<i16> {
395 Ok(self.read_u16_le()? as i16)
396 }
397
398 /// Reads a signed short as smart
399 ///
400 /// # Examples
401 ///
402 /// Example with a value less than 128. Here we can see that the first byte is returned.
403 ///
404 /// ```rust
405 /// use std::io::Cursor;
406 /// use osrs_bytes::ReadExt;
407 ///
408 /// let mut rdr = Cursor::new(vec![0]);
409 /// assert_eq!(rdr.read_i16_smart().unwrap(), -64);
410 /// ```
411 ///
412 /// ```rust
413 /// use std::io::Cursor;
414 /// use osrs_bytes::ReadExt;
415 ///
416 /// let mut rdr = Cursor::new(vec![0x40]);
417 /// assert_eq!(rdr.read_i16_smart().unwrap(), 0);
418 /// ```
419 ///
420 /// ```rust
421 /// use std::io::Cursor;
422 /// use osrs_bytes::ReadExt;
423 ///
424 /// let mut rdr = Cursor::new(vec![0x7F]);
425 /// assert_eq!(rdr.read_i16_smart().unwrap(), 0x3F);
426 /// ```
427 ///
428 /// ```rust
429 /// use std::io::Cursor;
430 /// use osrs_bytes::ReadExt;
431 ///
432 /// let mut rdr = Cursor::new(vec![0x80, 0x00]);
433 /// assert_eq!(rdr.read_i16_smart().unwrap(), -0x4000);
434 /// ```
435 ///
436 /// ```rust
437 /// use std::io::Cursor;
438 /// use osrs_bytes::ReadExt;
439 ///
440 /// let mut rdr = Cursor::new(vec![0xBF, 0xBF]);
441 /// assert_eq!(rdr.read_i16_smart().unwrap(), -0x41);
442 /// ```
443 ///
444 /// ```rust
445 /// use std::io::Cursor;
446 /// use osrs_bytes::ReadExt;
447 ///
448 /// let mut rdr = Cursor::new(vec![0xC0, 0x40]);
449 /// assert_eq!(rdr.read_i16_smart().unwrap(), 0x40);
450 /// ```
451 ///
452 /// ```rust
453 /// use std::io::Cursor;
454 /// use osrs_bytes::ReadExt;
455 ///
456 /// let mut rdr = Cursor::new(vec![0xFF, 0xFF]);
457 /// assert_eq!(rdr.read_i16_smart().unwrap(), 0x3FFF);
458 /// ```
459 #[inline]
460 fn read_i16_smart(&mut self) -> Result<i16> {
461 let peek = self.read_u8()?;
462 if peek & 128 == 0 {
463 Ok(peek as i16 - 64)
464 } else {
465 Ok((((peek as i16 & 0x7F) << 8) | (self.read_u8()? as i16) & 0x7FFF) - 16384)
466 }
467 }
468
469 /// Reads a signed short add
470 ///
471 /// # Examples
472 ///
473 /// ```rust
474 /// use std::io::Cursor;
475 /// use osrs_bytes::ReadExt;
476 ///
477 /// let mut rdr = Cursor::new(vec![253, 177]);
478 /// assert_eq!(rdr.read_i16_add().unwrap(), -719);
479 /// ```
480 #[inline]
481 fn read_i16_add(&mut self) -> Result<i16> {
482 Ok(self.read_u16_add()? as i16)
483 }
484
485 /// Reads an unsigned short add as little endian
486 ///
487 /// # Examples
488 ///
489 /// ```rust
490 /// use std::io::Cursor;
491 /// use osrs_bytes::ReadExt;
492 ///
493 /// let mut rdr = Cursor::new(vec![98, 255]);
494 /// assert_eq!(rdr.read_i16_add_le().unwrap(), -30);
495 /// ```
496 #[inline]
497 fn read_i16_add_le(&mut self) -> Result<i16> {
498 Ok(self.read_u16_add_le()? as i16)
499 }
500
501 /// Reads an unsigned medium as big endian
502 ///
503 /// # Examples
504 /// ```rust
505 /// use std::io::Cursor;
506 /// use osrs_bytes::ReadExt;
507 ///
508 /// let mut rdr = Cursor::new(vec![1, 2, 3]);
509 /// assert_eq!(rdr.read_u24().unwrap(), 66051);
510 /// ```
511 #[inline]
512 fn read_u24(&mut self) -> Result<u32> {
513 let mut buf = [0; 3];
514 self.read_exact(&mut buf)?;
515 Ok(u32::from_be_bytes([0, buf[0], buf[1], buf[2]]))
516 }
517
518 /// Reads an unsigned medium as little endian
519 ///
520 /// # Examples
521 /// ```rust
522 /// use std::io::Cursor;
523 /// use osrs_bytes::ReadExt;
524 ///
525 /// let mut rdr = Cursor::new(vec![3, 2, 1]);
526 /// assert_eq!(rdr.read_u24_le().unwrap(), 66051);
527 /// ```
528 #[inline]
529 fn read_u24_le(&mut self) -> Result<u32> {
530 let mut buf = [0; 3];
531 self.read_exact(&mut buf)?;
532 Ok(u32::from_le_bytes([buf[0], buf[1], buf[2], 0]))
533 }
534
535 /// Reads a signed medium as big endian
536 ///
537 /// # Examples
538 /// ```rust
539 /// use std::io::Cursor;
540 /// use osrs_bytes::ReadExt;
541 ///
542 /// let mut rdr = Cursor::new(vec![255, 255, 255]);
543 /// assert_eq!(rdr.read_i24().unwrap(), 16777215);
544 /// ```
545 #[inline]
546 fn read_i24(&mut self) -> Result<i32> {
547 Ok(self.read_u24()? as i32)
548 }
549
550 /// Reads a signed medium as little endian
551 ///
552 /// # Examples
553 /// ```rust
554 /// use std::io::Cursor;
555 /// use osrs_bytes::ReadExt;
556 ///
557 /// let mut rdr = Cursor::new(vec![255, 255, 255]);
558 /// assert_eq!(rdr.read_i24_le().unwrap(), 16777215);
559 /// ```
560 #[inline]
561 fn read_i24_le(&mut self) -> Result<i32> {
562 Ok(self.read_u24_le()? as i32)
563 }
564
565 /// Reads an unsigned dword as big endian
566 ///
567 /// # Examples
568 ///
569 /// ```rust
570 /// use std::io::Cursor;
571 /// use osrs_bytes::ReadExt;
572 ///
573 /// let mut rdr = Cursor::new(vec![42, 87, 33, 16]);
574 /// assert_eq!(rdr.read_u32().unwrap(), 710353168);
575 /// ```
576 #[inline]
577 fn read_u32(&mut self) -> Result<u32> {
578 let mut buf = [0; 4];
579 self.read_exact(&mut buf)?;
580 Ok(u32::from_be_bytes(buf))
581 }
582
583 /// Read an unsigned dword as a smart
584 ///
585 /// # Examples
586 ///
587 /// ```rust
588 /// use std::io::Cursor;
589 /// use osrs_bytes::ReadExt;
590 ///
591 /// let mut rdr = Cursor::new(vec![0x00, 0x00]);
592 /// assert_eq!(rdr.read_u32_smart().unwrap(), 0);
593 /// ```
594 ///
595 /// ```rust
596 /// use std::io::Cursor;
597 /// use osrs_bytes::ReadExt;
598 ///
599 /// let mut rdr = Cursor::new(vec![0x40, 0x00]);
600 /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x4000);
601 /// ```
602 ///
603 /// ```rust
604 /// use std::io::Cursor;
605 /// use osrs_bytes::ReadExt;
606 ///
607 /// let mut rdr = Cursor::new(vec![0x7F, 0xFF]);
608 /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x7FFF);
609 /// ```
610 ///
611 /// ```rust
612 /// use std::io::Cursor;
613 /// use osrs_bytes::ReadExt;
614 ///
615 /// let mut rdr = Cursor::new(vec![0x80, 0x00, 0x80, 0x00]);
616 /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x8000);
617 /// ```
618 ///
619 /// ```rust
620 /// use std::io::Cursor;
621 /// use osrs_bytes::ReadExt;
622 ///
623 /// let mut rdr = Cursor::new(vec![0xC0, 0x00, 0x00, 0x00]);
624 /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x40000000);
625 /// ```
626 ///
627 /// ```rust
628 /// use std::io::Cursor;
629 /// use osrs_bytes::ReadExt;
630 ///
631 /// let mut rdr = Cursor::new(vec![0xFF, 0xFF, 0xFF, 0xFF]);
632 /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x7FFFFFFF);
633 /// ```
634 #[inline]
635 fn read_u32_smart(&mut self) -> Result<u32> {
636 let peek = self.read_u8()?;
637 if peek & 128 == 0 {
638 Ok(((peek as u32 & 0x7F) << 8) | (self.read_u8()? as u32) & 0x7FFF)
639 } else {
640 Ok((((peek as u32 & 0x7F) << 24)
641 | ((self.read_u8()? as u32) << 16)
642 | ((self.read_u8()? as u32) << 8)
643 | (self.read_u8()? as u32))
644 & 0x7FFFFFFF)
645 }
646 }
647
648 /// Reads an unsigned dword as little endian
649 ///
650 /// # Examples
651 ///
652 /// ```rust
653 /// use std::io::Cursor;
654 /// use osrs_bytes::ReadExt;
655 ///
656 /// let mut rdr = Cursor::new(vec![16, 33, 87, 42]);
657 /// assert_eq!(rdr.read_u32_le().unwrap(), 710353168);
658 /// ```
659 #[inline]
660 fn read_u32_le(&mut self) -> Result<u32> {
661 let mut buf = [0; 4];
662 self.read_exact(&mut buf)?;
663 Ok(u32::from_le_bytes(buf))
664 }
665
666 /// Reads an unsigned dword as middle endian
667 ///
668 /// # Examples
669 ///
670 /// ```rust
671 /// use std::io::Cursor;
672 /// use osrs_bytes::ReadExt;
673 ///
674 /// let mut rdr = Cursor::new(vec![1, 5, 9, 49]);
675 /// assert_eq!(rdr.read_u32_me().unwrap(), 83964169);
676 ///
677 /// ```
678 #[inline]
679 fn read_u32_me(&mut self) -> Result<u32> {
680 Ok((self.read_u16_le()? as u32) << 16 | (self.read_u16_le()? as u32))
681 }
682
683 /// Reads an unsigned dword as inversed middle endian
684 ///
685 /// # Examples
686 ///
687 /// ```rust
688 /// use std::io::Cursor;
689 /// use osrs_bytes::ReadExt;
690 ///
691 /// let mut rdr = Cursor::new(vec![0, 0, 0, 149]);
692 /// assert_eq!(rdr.read_u32_ime().unwrap(), 9764864);
693 ///
694 /// ```
695 #[inline]
696 fn read_u32_ime(&mut self) -> Result<u32> {
697 Ok((self.read_u16()? as u32) | ((self.read_u16()? as u32) << 16))
698 }
699
700 /// Reads a signed dword as big endian
701 ///
702 /// # Examples
703 ///
704 /// ```rust
705 /// use std::io::Cursor;
706 /// use osrs_bytes::ReadExt;
707 ///
708 /// let mut rdr = Cursor::new(vec![255, 87, 33, 16]);
709 /// assert_eq!(rdr.read_i32().unwrap(), -11067120);
710 /// ```
711 #[inline]
712 fn read_i32(&mut self) -> Result<i32> {
713 Ok(self.read_u32()? as i32)
714 }
715
716 /// Read an signed dword as a smart
717 ///
718 /// # Examples
719 ///
720 /// ```rust
721 /// use std::io::Cursor;
722 /// use osrs_bytes::ReadExt;
723 ///
724 /// let mut rdr = Cursor::new(vec![0x00, 0x00]);
725 /// assert_eq!(rdr.read_i32_smart().unwrap(), -0x4000);
726 /// ```
727 ///
728 /// ```rust
729 /// use std::io::Cursor;
730 /// use osrs_bytes::ReadExt;
731 ///
732 /// let mut rdr = Cursor::new(vec![0x40, 0x00]);
733 /// assert_eq!(rdr.read_i32_smart().unwrap(), 0);
734 /// ```
735 ///
736 /// ```rust
737 /// use std::io::Cursor;
738 /// use osrs_bytes::ReadExt;
739 ///
740 /// let mut rdr = Cursor::new(vec![0x7F, 0xFF]);
741 /// assert_eq!(rdr.read_i32_smart().unwrap(), 0x3FFF);
742 /// ```
743 ///
744 /// ```rust
745 /// use std::io::Cursor;
746 /// use osrs_bytes::ReadExt;
747 ///
748 /// let mut rdr = Cursor::new(vec![0x80, 0x00, 0x00, 0x00]);
749 /// assert_eq!(rdr.read_i32_smart().unwrap(), -0x40000000);
750 /// ```
751 ///
752 /// ```rust
753 /// use std::io::Cursor;
754 /// use osrs_bytes::ReadExt;
755 ///
756 /// let mut rdr = Cursor::new(vec![0xBF, 0xFF, 0xBF, 0xFF]);
757 /// assert_eq!(rdr.read_i32_smart().unwrap(), -0x4001);
758 /// ```
759 ///
760 /// ```rust
761 /// use std::io::Cursor;
762 /// use osrs_bytes::ReadExt;
763 ///
764 /// let mut rdr = Cursor::new(vec![0xC0, 0x00, 0x40, 0x00]);
765 /// assert_eq!(rdr.read_i32_smart().unwrap(), 0x4000);
766 /// ```
767 ///
768 /// ```rust
769 /// use std::io::Cursor;
770 /// use osrs_bytes::ReadExt;
771 ///
772 /// let mut rdr = Cursor::new(vec![0xFF, 0xFF, 0xFF, 0xFF]);
773 /// assert_eq!(rdr.read_i32_smart().unwrap(), 0x3FFFFFFF);
774 /// ```
775 #[inline]
776 fn read_i32_smart(&mut self) -> Result<i32> {
777 let peek = self.read_u8()?;
778 if peek & 128 == 0 {
779 Ok((((peek as i32 & 0x7F) << 8) | (self.read_u8()? as i32) & 0x7FFF) - 0x4000)
780 } else {
781 Ok(((((peek as i32 & 0x7F) << 24)
782 | ((self.read_u8()? as i32) << 16)
783 | ((self.read_u8()? as i32) << 8)
784 | (self.read_u8()? as i32))
785 & 0x7FFFFFFF)
786 - 0x40000000)
787 }
788 }
789
790 /// Reads an signed dword as little endian
791 ///
792 /// # Examples
793 ///
794 /// ```rust
795 /// use std::io::Cursor;
796 /// use osrs_bytes::ReadExt;
797 ///
798 /// let mut rdr = Cursor::new(vec![16, 33, 87, 250]);
799 /// assert_eq!(rdr.read_i32_le().unwrap(), -94953200);
800 /// ```
801 #[inline]
802 fn read_i32_le(&mut self) -> Result<i32> {
803 Ok(self.read_u32_le()? as i32)
804 }
805
806 /// Reads an signed dword as middle endian
807 ///
808 /// # Examples
809 ///
810 /// ```rust
811 /// use std::io::Cursor;
812 /// use osrs_bytes::ReadExt;
813 ///
814 /// let mut rdr = Cursor::new(vec![0, 149, 0, 0]);
815 /// assert_eq!(rdr.read_i32_me().unwrap(), -1795162112);
816 ///
817 /// ```
818 #[inline]
819 fn read_i32_me(&mut self) -> Result<i32> {
820 Ok(self.read_u32_me()? as i32)
821 }
822
823 /// Reads an unsigned dword as inversed middle endian
824 ///
825 /// # Examples
826 ///
827 /// ```rust
828 /// use std::io::Cursor;
829 /// use osrs_bytes::ReadExt;
830 ///
831 /// let mut rdr = Cursor::new(vec![118, 195, 254, 193]);
832 /// assert_eq!(rdr.read_i32_ime().unwrap(), -20875581);
833 ///
834 /// ```
835 #[inline]
836 fn read_i32_ime(&mut self) -> Result<i32> {
837 Ok(self.read_u32_ime()? as i32)
838 }
839
840 /// Reads an unsigned dword as big endian
841 ///
842 /// # Examples
843 ///
844 /// ```rust
845 /// use std::io::Cursor;
846 /// use osrs_bytes::ReadExt;
847 ///
848 /// let mut rdr = Cursor::new(vec![31, 84, 11, 99, 45, 12, 94, 36]);
849 /// assert_eq!(rdr.read_u64().unwrap(), 2257441833804914212);
850 /// ```
851 #[inline]
852 fn read_u64(&mut self) -> Result<u64> {
853 let mut buf = [0; 8];
854 self.read_exact(&mut buf)?;
855 Ok(u64::from_be_bytes(buf))
856 }
857
858 /// Reads an signed dword as big endian
859 ///
860 /// # Examples
861 ///
862 /// ```rust
863 /// use std::io::Cursor;
864 /// use osrs_bytes::ReadExt;
865 ///
866 /// let mut rdr = Cursor::new(vec![255, 84, 11, 99, 45, 12, 94, 36]);
867 /// assert_eq!(rdr.read_i64().unwrap(), -48401175408779740);
868 /// ```
869 #[inline]
870 fn read_i64(&mut self) -> Result<i64> {
871 Ok(self.read_u64()? as i64)
872 }
873
874 /// Reads a CP1252 string
875 ///
876 /// # Examples
877 ///
878 /// ```rust
879 /// use std::io::Cursor;
880 /// use osrs_bytes::ReadExt;
881 ///
882 /// let mut rdr = Cursor::new(vec![109, 121, 32, 116, 101, 115, 116, 0]);
883 /// assert_eq!(rdr.read_string_cp1252().unwrap(), "my test");
884 /// ```
885 #[inline]
886 fn read_string_cp1252(&mut self) -> Result<String> {
887 let mut str = Vec::new();
888
889 while let Ok(x) = self.read_u8() {
890 if x != 0 {
891 str.push(x);
892 } else {
893 break;
894 }
895 }
896
897 let s = match std::str::from_utf8(&str) {
898 Ok(v) => v,
899 Err(e) => {
900 return Err(Error::new(
901 ErrorKind::Other,
902 format!("Invalid UTF-8 sequence: {}", e),
903 ))
904 }
905 };
906
907 Ok(s.to_owned())
908 }
909}
910
911impl<R: io::Read + ?Sized> ReadExt for R {}
912
913pub trait WriteExt: Write {
914 /// Writes an unsigned byte to the writer.
915 ///
916 /// Examples
917 ///
918 /// ```rust
919 /// use osrs_bytes::WriteExt;
920 ///
921 /// let mut wtr = Vec::new();
922 /// wtr.write_u8(42).unwrap();
923 /// assert_eq!(wtr[0], 42);
924 /// ```
925 #[inline]
926 fn write_u8(&mut self, n: u8) -> Result<()> {
927 self.write_all(&[n])
928 }
929
930 /// Writes an unsigned byte to the writer.
931 ///
932 /// # Examples
933 ///
934 /// ```rust
935 /// use osrs_bytes::WriteExt;
936 ///
937 /// let mut wtr = Vec::new();
938 /// wtr.write_u8_add(42).unwrap();
939 /// assert_eq!(wtr[0], 170);
940 /// ```
941 ///
942 /// ```rust
943 /// use osrs_bytes::WriteExt;
944 ///
945 /// let mut wtr = Vec::new();
946 /// wtr.write_u8_add(128).unwrap();
947 /// assert_eq!(wtr[0], 0);
948 /// ```
949 #[inline]
950 fn write_u8_add(&mut self, n: u8) -> Result<()> {
951 self.write_u8(n.wrapping_add(128))
952 }
953
954 /// Writes an unsigned byte to the writer.
955 ///
956 /// # Examples
957 ///
958 /// ```rust
959 /// use osrs_bytes::WriteExt;
960 ///
961 /// let mut wtr = Vec::new();
962 /// wtr.write_u8_neg(42).unwrap();
963 /// assert_eq!(wtr[0], 214);
964 /// ```
965 ///
966 /// ```rust
967 /// use osrs_bytes::WriteExt;
968 ///
969 /// let mut wtr = Vec::new();
970 /// wtr.write_u8_neg(0).unwrap();
971 /// assert_eq!(wtr[0], 0);
972 /// ```
973 #[inline]
974 fn write_u8_neg(&mut self, n: u8) -> Result<()> {
975 self.write_u8(0u8.wrapping_sub(n))
976 }
977
978 /// Writes an unsigned byte to the writer.
979 ///
980 /// # Examples
981 ///
982 /// ```rust
983 /// use osrs_bytes::WriteExt;
984 ///
985 /// let mut wtr = Vec::new();
986 /// wtr.write_u8_sub(42).unwrap();
987 /// assert_eq!(wtr[0], 86);
988 /// ```
989 ///
990 /// ```rust
991 /// use osrs_bytes::WriteExt;
992 ///
993 /// let mut wtr = Vec::new();
994 /// wtr.write_u8_sub(128).unwrap();
995 /// assert_eq!(wtr[0], 0);
996 /// ```
997 #[inline]
998 fn write_u8_sub(&mut self, n: u8) -> Result<()> {
999 self.write_u8(128u8.wrapping_sub(n))
1000 }
1001
1002 /// Writes an signed byte to the writer.
1003 ///
1004 /// Examples
1005 ///
1006 /// ```rust
1007 /// use osrs_bytes::WriteExt;
1008 ///
1009 /// let mut wtr = Vec::new();
1010 /// wtr.write_i8(-67).unwrap();
1011 /// assert_eq!(wtr[0] as i8, -67);
1012 /// ```
1013 #[inline]
1014 fn write_i8(&mut self, n: i8) -> Result<()> {
1015 self.write_u8(n as u8)
1016 }
1017
1018 /// Writes the number 128, subtracted by the signed byte to the writer.
1019 ///
1020 /// # Examples
1021 ///
1022 /// ```rust
1023 /// use osrs_bytes::WriteExt;
1024 ///
1025 /// let mut wtr = Vec::new();
1026 /// wtr.write_i8_sub(99).unwrap();
1027 /// assert_eq!(wtr[0] as i8, 29);
1028 /// ```
1029 #[inline]
1030 fn write_i8_sub(&mut self, n: i8) -> Result<()> {
1031 self.write_u8_sub(n as u8)
1032 }
1033
1034 /// Writes the byte and adds 128.
1035 ///
1036 /// # Examples
1037 ///
1038 /// ```rust
1039 /// use osrs_bytes::WriteExt;
1040 ///
1041 /// let mut wtr = Vec::new();
1042 /// wtr.write_i8_add(42).unwrap();
1043 /// assert_eq!(wtr[0], 170);
1044 /// ```
1045 #[inline]
1046 fn write_i8_add(&mut self, n: i8) -> Result<()> {
1047 self.write_u8_add(n as u8)
1048 }
1049
1050 /// Writes a negated byte to the writer.
1051 ///
1052 /// # Examples
1053 ///
1054 /// ```rust
1055 /// use osrs_bytes::WriteExt;
1056 ///
1057 /// let mut wtr = Vec::new();
1058 /// wtr.write_i8_neg(55).unwrap();
1059 /// assert_eq!(wtr[0], 201);
1060 /// ```
1061 #[inline]
1062 fn write_i8_neg(&mut self, n: i8) -> Result<()> {
1063 self.write_u8_neg(n as u8)
1064 }
1065
1066 /// Writes a bool to the writer.
1067 ///
1068 /// Examples
1069 ///
1070 /// ```rust
1071 /// use osrs_bytes::WriteExt;
1072 ///
1073 /// let mut wtr = Vec::new();
1074 /// wtr.write_bool(true).unwrap();
1075 /// assert_eq!(wtr[0], 1);
1076 /// ```
1077 #[inline]
1078 fn write_bool(&mut self, b: bool) -> Result<()> {
1079 self.write_all(&[b as u8])
1080 }
1081
1082 /// Writes an unsigned short to the writer.
1083 ///
1084 /// # Examples
1085 ///
1086 /// ```rust
1087 /// use osrs_bytes::WriteExt;
1088 ///
1089 /// let mut wtr = Vec::new();
1090 /// wtr.write_u16(20065).unwrap();
1091 /// assert_eq!(wtr[0], 78);
1092 /// assert_eq!(wtr[1], 97);
1093 /// ```
1094 #[inline]
1095 fn write_u16(&mut self, n: u16) -> Result<()> {
1096 self.write_all(&n.to_be_bytes())
1097 }
1098
1099 /// Writes an unsigned short as a little endian to the writer.
1100 ///
1101 /// # Examples
1102 ///
1103 /// ```rust
1104 /// use osrs_bytes::WriteExt;
1105 ///
1106 /// let mut wtr = Vec::new();
1107 /// wtr.write_u16_le(29543).unwrap();
1108 /// assert_eq!(wtr[0], 103);
1109 /// assert_eq!(wtr[1], 115);
1110 /// ```
1111 ///
1112 #[inline]
1113 fn write_u16_le(&mut self, n: u16) -> Result<()> {
1114 self.write_all(&n.to_le_bytes())
1115 }
1116
1117 /// Writes an unsigned short smart to the writer.
1118 ///
1119 /// # Examples
1120 ///
1121 /// Writing a value lesser than or equal to 127 makes it write out a single unsigned byte.
1122 ///
1123 /// ```rust
1124 /// use osrs_bytes::WriteExt;
1125 ///
1126 /// let mut wtr = Vec::new();
1127 /// wtr.write_u16_smart(65).unwrap();
1128 /// assert_eq!(wtr[0], 65);
1129 /// assert!(wtr.get(1).is_none());
1130 /// ```
1131 ///
1132 /// Writing a value greater than 127 will make it write out two unsigned bytes.
1133 ///
1134 /// ```rust
1135 /// use osrs_bytes::WriteExt;
1136 ///
1137 /// let mut wtr = Vec::new();
1138 /// wtr.write_u16_smart(986).unwrap();
1139 /// assert_eq!(wtr[0], 131);
1140 /// assert_eq!(wtr[1], 218);
1141 /// ```
1142 ///
1143 #[inline]
1144 fn write_u16_smart(&mut self, n: u16) -> Result<()> {
1145 match n {
1146 0..=127 => self.write_u8(n as u8),
1147 128..=32767 => self.write_u16(n + 32768),
1148 _ => Err(Error::new(
1149 ErrorKind::Other,
1150 format!("Failed writing smart, value is {}", n),
1151 )),
1152 }
1153 }
1154
1155 /// Writes a signed short to the writer.
1156 ///
1157 /// # Examples
1158 ///
1159 /// ```rust
1160 /// use osrs_bytes::WriteExt;
1161 ///
1162 /// let mut wtr = Vec::new();
1163 /// wtr.write_i16(-14632).unwrap();
1164 /// assert_eq!(wtr[0], 198);
1165 /// assert_eq!(wtr[1], 216);
1166 /// ```
1167 #[inline]
1168 fn write_i16(&mut self, n: i16) -> Result<()> {
1169 self.write_u16(n as u16)
1170 }
1171
1172 /// Writes a signed short as little endian to the writer.
1173 ///
1174 /// # Examples
1175 ///
1176 /// ```rust
1177 /// use osrs_bytes::WriteExt;
1178 ///
1179 /// let mut wtr = Vec::new();
1180 /// wtr.write_i16_le(-7654).unwrap();
1181 /// assert_eq!(wtr[0], 26);
1182 /// assert_eq!(wtr[1], 226);
1183 /// ```
1184 #[inline]
1185 fn write_i16_le(&mut self, n: i16) -> Result<()> {
1186 self.write_u16_le(n as u16)
1187 }
1188
1189 /// Writes a signed short add to the writer.
1190 ///
1191 /// # Examples
1192 ///
1193 /// ```rust
1194 /// use osrs_bytes::WriteExt;
1195 ///
1196 /// let mut wtr = Vec::new();
1197 /// wtr.write_i16_add(-9867).unwrap();
1198 /// assert_eq!(wtr[0], 217);
1199 /// assert_eq!(wtr[1], 245);
1200 /// ```
1201 ///
1202 #[inline]
1203 fn write_i16_add(&mut self, n: i16) -> Result<()> {
1204 self.write_i8((n >> 8) as i8)?;
1205 self.write_i8((n + 128) as i8)
1206 }
1207
1208 /// Writes a signed short add as a little endian to the writer.
1209 ///
1210 /// # Examples
1211 ///
1212 /// ```rust
1213 /// use osrs_bytes::WriteExt;
1214 ///
1215 /// let mut wtr = Vec::new();
1216 /// wtr.write_i16_add_le(-12632).unwrap();
1217 /// assert_eq!(wtr[0], 40);
1218 /// assert_eq!(wtr[1], 206);
1219 /// ```
1220 ///
1221 #[inline]
1222 fn write_i16_add_le(&mut self, n: i16) -> Result<()> {
1223 self.write_i8((n + 128) as i8)?;
1224 self.write_i8((n >> 8) as i8)
1225 }
1226
1227 /// Writes an unsigned dword to the writer.
1228 ///
1229 /// # Examples
1230 ///
1231 /// ```rust
1232 /// use osrs_bytes::WriteExt;
1233 ///
1234 /// let mut wtr = Vec::new();
1235 /// wtr.write_u32(98571).unwrap();
1236 /// assert_eq!(wtr[0], 0);
1237 /// assert_eq!(wtr[1], 1);
1238 /// assert_eq!(wtr[2], 129);
1239 /// assert_eq!(wtr[3], 11);
1240 /// ```
1241 ///
1242 #[inline]
1243 fn write_u32(&mut self, n: u32) -> Result<()> {
1244 self.write_all(&n.to_be_bytes())
1245 }
1246
1247 /// Writes am unsigned integer as little endian to the writer.
1248 ///
1249 /// # Examples
1250 ///
1251 /// ```rust
1252 /// use osrs_bytes::WriteExt;
1253 ///
1254 /// let mut wtr = Vec::new();
1255 /// wtr.write_u32_le(26904).unwrap();
1256 /// assert_eq!(wtr[0], 24);
1257 /// assert_eq!(wtr[1], 105);
1258 /// assert_eq!(wtr[2], 0);
1259 /// assert_eq!(wtr[3], 0);
1260 /// ```
1261 ///
1262 #[inline]
1263 fn write_u32_le(&mut self, n: u32) -> Result<()> {
1264 self.write_all(&n.to_le_bytes())
1265 }
1266
1267 /// Writes a signed dword to the writer.
1268 ///
1269 /// # Examples
1270 ///
1271 /// ```rust
1272 /// use osrs_bytes::WriteExt;
1273 ///
1274 /// let mut wtr = Vec::new();
1275 /// wtr.write_i32(-131045).unwrap();
1276 /// assert_eq!(wtr[0], 255);
1277 /// assert_eq!(wtr[1], 254);
1278 /// assert_eq!(wtr[2], 0);
1279 /// assert_eq!(wtr[3], 27);
1280 /// ```
1281 ///
1282 #[inline]
1283 fn write_i32(&mut self, n: i32) -> Result<()> {
1284 self.write_u32(n as u32)
1285 }
1286
1287 /// Writes a signed integer as little endian to the writer.
1288 ///
1289 /// # Examples
1290 ///
1291 /// ```rust
1292 /// use osrs_bytes::WriteExt;
1293 ///
1294 /// let mut wtr = Vec::new();
1295 /// wtr.write_i32_le(18879).unwrap();
1296 /// assert_eq!(wtr[0], 191);
1297 /// assert_eq!(wtr[1], 73);
1298 /// assert_eq!(wtr[2], 0);
1299 /// assert_eq!(wtr[3], 0);
1300 /// ```
1301 ///
1302 #[inline]
1303 fn write_i32_le(&mut self, n: i32) -> Result<()> {
1304 self.write_u32_le(n as u32)
1305 }
1306
1307 /// Writes a signed dword as a middle endian to the writer.
1308 ///
1309 /// # Examples
1310 ///
1311 /// ```rust
1312 /// use osrs_bytes::WriteExt;
1313 ///
1314 /// let mut wtr = Vec::new();
1315 /// wtr.write_i32_me(-98231).unwrap();
1316 /// assert_eq!(wtr[0], 254);
1317 /// assert_eq!(wtr[1], 255);
1318 /// assert_eq!(wtr[2], 73);
1319 /// assert_eq!(wtr[3], 128);
1320 /// ```
1321 ///
1322 #[inline]
1323 fn write_i32_me(&mut self, n: i32) -> Result<()> {
1324 self.write_i16_le((n >> 16) as i16)?;
1325 self.write_i16_le(n as i16)
1326 }
1327
1328 /// Writes a signed dword as an inversed middle endian to the writer.
1329 ///
1330 /// # Examples
1331 ///
1332 /// ```rust
1333 /// use osrs_bytes::WriteExt;
1334 ///
1335 /// let mut wtr = Vec::new();
1336 /// wtr.write_i32_ime(-98231).unwrap();
1337 /// assert_eq!(wtr[0], 128);
1338 /// assert_eq!(wtr[1], 73);
1339 /// assert_eq!(wtr[2], 255);
1340 /// assert_eq!(wtr[3], 254);
1341 /// ```
1342 ///
1343 #[inline]
1344 fn write_i32_ime(&mut self, n: i32) -> Result<()> {
1345 self.write_i16(n as i16)?;
1346 self.write_i16((n >> 16) as i16)
1347 }
1348
1349 /// Writes an unsigned qword to the writer.
1350 ///
1351 /// # Examples
1352 ///
1353 /// ```rust
1354 /// use osrs_bytes::WriteExt;
1355 ///
1356 /// let mut wtr = Vec::new();
1357 /// wtr.write_u64(8589934592).unwrap();
1358 /// assert_eq!(wtr[0], 0);
1359 /// assert_eq!(wtr[1], 0);
1360 /// assert_eq!(wtr[2], 0);
1361 /// assert_eq!(wtr[3], 2);
1362 /// assert_eq!(wtr[4], 0);
1363 /// assert_eq!(wtr[5], 0);
1364 /// assert_eq!(wtr[6], 0);
1365 /// assert_eq!(wtr[7], 0);
1366 /// ```
1367 ///
1368 #[inline]
1369 fn write_u64(&mut self, n: u64) -> Result<()> {
1370 self.write_all(&n.to_be_bytes())
1371 }
1372
1373 /// Writes a signed qword to the writer.
1374 ///
1375 /// # Examples
1376 ///
1377 /// ```rust
1378 /// use osrs_bytes::WriteExt;
1379 ///
1380 /// let mut wtr = Vec::new();
1381 /// wtr.write_i64(-8589934592).unwrap();
1382 /// assert_eq!(wtr[0], 255);
1383 /// assert_eq!(wtr[1], 255);
1384 /// assert_eq!(wtr[2], 255);
1385 /// assert_eq!(wtr[3], 254);
1386 /// assert_eq!(wtr[4], 0);
1387 /// assert_eq!(wtr[5], 0);
1388 /// assert_eq!(wtr[6], 0);
1389 /// assert_eq!(wtr[7], 0);
1390 /// ```
1391 ///
1392 #[inline]
1393 fn write_i64(&mut self, n: i64) -> Result<()> {
1394 self.write_u64(n as u64)
1395 }
1396
1397 /// Writes a CP1252 string to the writer.
1398 ///
1399 /// # Examples
1400 ///
1401 /// ```rust
1402 /// use osrs_bytes::WriteExt;
1403 ///
1404 /// let mut wtr = Vec::new();
1405 /// wtr.write_string_cp1252("hello").unwrap();
1406 /// assert_eq!(wtr[0], 104);
1407 /// assert_eq!(wtr[1], 101);
1408 /// assert_eq!(wtr[2], 108);
1409 /// assert_eq!(wtr[3], 108);
1410 /// assert_eq!(wtr[4], 111);
1411 /// assert_eq!(wtr[5], 0);
1412 /// ```
1413 ///
1414 #[inline]
1415 fn write_string_cp1252<T: AsRef<str>>(&mut self, s: T) -> Result<()> {
1416 for b in s.as_ref().as_bytes() {
1417 self.write_u8(*b)?;
1418 }
1419 self.write_i8(0)
1420 }
1421
1422 /// Write bytes reversed with add to the writer.
1423 ///
1424 /// # Examples
1425 ///
1426 /// ```rust
1427 /// use osrs_bytes::WriteExt;
1428 ///
1429 /// let wtr1 = vec![1, 2, 3];
1430 ///
1431 /// let mut wtr2 = Vec::new();
1432 /// wtr2.write_bytes_reversed_add(&wtr1);
1433 /// assert_eq!(wtr2[0], 131);
1434 /// assert_eq!(wtr2[1], 130);
1435 /// assert_eq!(wtr2[2], 129);
1436 /// ```
1437 ///
1438 #[inline]
1439 fn write_bytes_reversed_add(&mut self, buf: &[u8]) -> Result<()> {
1440 for b in buf.iter().rev() {
1441 self.write_u8_add(*b)?;
1442 }
1443 Ok(())
1444 }
1445}
1446
1447impl<W: io::Write + ?Sized> WriteExt for W {}
1448
1449/*
1450#[cfg(test)]
1451mod tests {
1452 //use super::*;
1453
1454 // Tests that do not fit in documentation should be placed here.
1455
1456
1457 #[test]
1458 fn test_write_u8() {
1459 ...
1460 }
1461}
1462*/