1 macro_rules! impl_partial_eq { 2 ($lhs:ty, $rhs:ty) => { 3 impl<'a, 'b> PartialEq<$rhs> for $lhs { 4 #[inline] 5 fn eq(&self, other: &$rhs) -> bool { 6 let other: &[u8] = other.as_ref(); 7 PartialEq::eq(self.as_bytes(), other) 8 } 9 } 10 11 impl<'a, 'b> PartialEq<$lhs> for $rhs { 12 #[inline] 13 fn eq(&self, other: &$lhs) -> bool { 14 let this: &[u8] = self.as_ref(); 15 PartialEq::eq(this, other.as_bytes()) 16 } 17 } 18 }; 19 } 20 21 #[cfg(feature = "std")] 22 macro_rules! impl_partial_eq_cow { 23 ($lhs:ty, $rhs:ty) => { 24 impl<'a, 'b> PartialEq<$rhs> for $lhs { 25 #[inline] 26 fn eq(&self, other: &$rhs) -> bool { 27 let other: &[u8] = (&**other).as_ref(); 28 PartialEq::eq(self.as_bytes(), other) 29 } 30 } 31 32 impl<'a, 'b> PartialEq<$lhs> for $rhs { 33 #[inline] 34 fn eq(&self, other: &$lhs) -> bool { 35 let this: &[u8] = (&**other).as_ref(); 36 PartialEq::eq(this, other.as_bytes()) 37 } 38 } 39 }; 40 } 41 42 macro_rules! impl_partial_ord { 43 ($lhs:ty, $rhs:ty) => { 44 impl<'a, 'b> PartialOrd<$rhs> for $lhs { 45 #[inline] 46 fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> { 47 let other: &[u8] = other.as_ref(); 48 PartialOrd::partial_cmp(self.as_bytes(), other) 49 } 50 } 51 52 impl<'a, 'b> PartialOrd<$lhs> for $rhs { 53 #[inline] 54 fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> { 55 let this: &[u8] = self.as_ref(); 56 PartialOrd::partial_cmp(this, other.as_bytes()) 57 } 58 } 59 }; 60 } 61 62 #[cfg(feature = "std")] 63 mod bstring { 64 use std::borrow::{Borrow, Cow, ToOwned}; 65 use std::cmp::Ordering; 66 use std::fmt; 67 use std::iter::FromIterator; 68 use std::ops; 69 70 use bstr::BStr; 71 use bstring::BString; 72 use ext_vec::ByteVec; 73 74 impl fmt::Display for BString { 75 #[inline] fmt(&self, f: &mut fmt::Formatter) -> fmt::Result76 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 77 fmt::Display::fmt(self.as_bstr(), f) 78 } 79 } 80 81 impl fmt::Debug for BString { 82 #[inline] fmt(&self, f: &mut fmt::Formatter) -> fmt::Result83 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 84 fmt::Debug::fmt(self.as_bstr(), f) 85 } 86 } 87 88 impl ops::Deref for BString { 89 type Target = Vec<u8>; 90 91 #[inline] deref(&self) -> &Vec<u8>92 fn deref(&self) -> &Vec<u8> { 93 &self.bytes 94 } 95 } 96 97 impl ops::DerefMut for BString { 98 #[inline] deref_mut(&mut self) -> &mut Vec<u8>99 fn deref_mut(&mut self) -> &mut Vec<u8> { 100 &mut self.bytes 101 } 102 } 103 104 impl AsRef<[u8]> for BString { 105 #[inline] as_ref(&self) -> &[u8]106 fn as_ref(&self) -> &[u8] { 107 &self.bytes 108 } 109 } 110 111 impl AsRef<BStr> for BString { 112 #[inline] as_ref(&self) -> &BStr113 fn as_ref(&self) -> &BStr { 114 self.as_bstr() 115 } 116 } 117 118 impl AsMut<[u8]> for BString { 119 #[inline] as_mut(&mut self) -> &mut [u8]120 fn as_mut(&mut self) -> &mut [u8] { 121 &mut self.bytes 122 } 123 } 124 125 impl AsMut<BStr> for BString { 126 #[inline] as_mut(&mut self) -> &mut BStr127 fn as_mut(&mut self) -> &mut BStr { 128 self.as_mut_bstr() 129 } 130 } 131 132 impl Borrow<BStr> for BString { 133 #[inline] borrow(&self) -> &BStr134 fn borrow(&self) -> &BStr { 135 self.as_bstr() 136 } 137 } 138 139 impl ToOwned for BStr { 140 type Owned = BString; 141 142 #[inline] to_owned(&self) -> BString143 fn to_owned(&self) -> BString { 144 BString::from(self) 145 } 146 } 147 148 impl Default for BString { default() -> BString149 fn default() -> BString { 150 BString::from(vec![]) 151 } 152 } 153 154 impl<'a> From<&'a [u8]> for BString { 155 #[inline] from(s: &'a [u8]) -> BString156 fn from(s: &'a [u8]) -> BString { 157 BString::from(s.to_vec()) 158 } 159 } 160 161 impl From<Vec<u8>> for BString { 162 #[inline] from(s: Vec<u8>) -> BString163 fn from(s: Vec<u8>) -> BString { 164 BString { bytes: s } 165 } 166 } 167 168 impl From<BString> for Vec<u8> { 169 #[inline] from(s: BString) -> Vec<u8>170 fn from(s: BString) -> Vec<u8> { 171 s.bytes 172 } 173 } 174 175 impl<'a> From<&'a str> for BString { 176 #[inline] from(s: &'a str) -> BString177 fn from(s: &'a str) -> BString { 178 BString::from(s.as_bytes().to_vec()) 179 } 180 } 181 182 impl From<String> for BString { 183 #[inline] from(s: String) -> BString184 fn from(s: String) -> BString { 185 BString::from(s.into_bytes()) 186 } 187 } 188 189 impl<'a> From<&'a BStr> for BString { 190 #[inline] from(s: &'a BStr) -> BString191 fn from(s: &'a BStr) -> BString { 192 BString::from(s.bytes.to_vec()) 193 } 194 } 195 196 impl<'a> From<BString> for Cow<'a, BStr> { 197 #[inline] from(s: BString) -> Cow<'a, BStr>198 fn from(s: BString) -> Cow<'a, BStr> { 199 Cow::Owned(s) 200 } 201 } 202 203 impl FromIterator<char> for BString { 204 #[inline] from_iter<T: IntoIterator<Item = char>>(iter: T) -> BString205 fn from_iter<T: IntoIterator<Item = char>>(iter: T) -> BString { 206 BString::from(iter.into_iter().collect::<String>()) 207 } 208 } 209 210 impl FromIterator<u8> for BString { 211 #[inline] from_iter<T: IntoIterator<Item = u8>>(iter: T) -> BString212 fn from_iter<T: IntoIterator<Item = u8>>(iter: T) -> BString { 213 BString::from(iter.into_iter().collect::<Vec<u8>>()) 214 } 215 } 216 217 impl<'a> FromIterator<&'a str> for BString { 218 #[inline] from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> BString219 fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> BString { 220 let mut buf = vec![]; 221 for b in iter { 222 buf.push_str(b); 223 } 224 BString::from(buf) 225 } 226 } 227 228 impl<'a> FromIterator<&'a [u8]> for BString { 229 #[inline] from_iter<T: IntoIterator<Item = &'a [u8]>>(iter: T) -> BString230 fn from_iter<T: IntoIterator<Item = &'a [u8]>>(iter: T) -> BString { 231 let mut buf = vec![]; 232 for b in iter { 233 buf.push_str(b); 234 } 235 BString::from(buf) 236 } 237 } 238 239 impl<'a> FromIterator<&'a BStr> for BString { 240 #[inline] from_iter<T: IntoIterator<Item = &'a BStr>>(iter: T) -> BString241 fn from_iter<T: IntoIterator<Item = &'a BStr>>(iter: T) -> BString { 242 let mut buf = vec![]; 243 for b in iter { 244 buf.push_str(b); 245 } 246 BString::from(buf) 247 } 248 } 249 250 impl FromIterator<BString> for BString { 251 #[inline] from_iter<T: IntoIterator<Item = BString>>(iter: T) -> BString252 fn from_iter<T: IntoIterator<Item = BString>>(iter: T) -> BString { 253 let mut buf = vec![]; 254 for b in iter { 255 buf.push_str(b); 256 } 257 BString::from(buf) 258 } 259 } 260 261 impl Eq for BString {} 262 263 impl PartialEq for BString { 264 #[inline] eq(&self, other: &BString) -> bool265 fn eq(&self, other: &BString) -> bool { 266 &self[..] == &other[..] 267 } 268 } 269 270 impl_partial_eq!(BString, Vec<u8>); 271 impl_partial_eq!(BString, [u8]); 272 impl_partial_eq!(BString, &'a [u8]); 273 impl_partial_eq!(BString, String); 274 impl_partial_eq!(BString, str); 275 impl_partial_eq!(BString, &'a str); 276 impl_partial_eq!(BString, BStr); 277 impl_partial_eq!(BString, &'a BStr); 278 279 impl PartialOrd for BString { 280 #[inline] partial_cmp(&self, other: &BString) -> Option<Ordering>281 fn partial_cmp(&self, other: &BString) -> Option<Ordering> { 282 PartialOrd::partial_cmp(&self.bytes, &other.bytes) 283 } 284 } 285 286 impl Ord for BString { 287 #[inline] cmp(&self, other: &BString) -> Ordering288 fn cmp(&self, other: &BString) -> Ordering { 289 self.partial_cmp(other).unwrap() 290 } 291 } 292 293 impl_partial_ord!(BString, Vec<u8>); 294 impl_partial_ord!(BString, [u8]); 295 impl_partial_ord!(BString, &'a [u8]); 296 impl_partial_ord!(BString, String); 297 impl_partial_ord!(BString, str); 298 impl_partial_ord!(BString, &'a str); 299 impl_partial_ord!(BString, BStr); 300 impl_partial_ord!(BString, &'a BStr); 301 } 302 303 mod bstr { 304 #[cfg(feature = "std")] 305 use std::borrow::Cow; 306 307 use core::cmp::Ordering; 308 use core::fmt; 309 use core::ops; 310 311 use bstr::BStr; 312 use ext_slice::ByteSlice; 313 314 impl fmt::Display for BStr { 315 #[inline] fmt(&self, f: &mut fmt::Formatter) -> fmt::Result316 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 317 for chunk in self.utf8_chunks() { 318 f.write_str(chunk.valid())?; 319 if !chunk.invalid().is_empty() { 320 f.write_str("\u{FFFD}")?; 321 } 322 } 323 Ok(()) 324 } 325 } 326 327 impl fmt::Debug for BStr { 328 #[inline] fmt(&self, f: &mut fmt::Formatter) -> fmt::Result329 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 330 write!(f, "\"")?; 331 for (s, e, ch) in self.char_indices() { 332 if ch == '\u{FFFD}' { 333 for &b in self[s..e].as_bytes() { 334 write!(f, r"\x{:X}", b)?; 335 } 336 } else { 337 write!(f, "{}", ch.escape_debug())?; 338 } 339 } 340 write!(f, "\"")?; 341 Ok(()) 342 } 343 } 344 345 impl ops::Deref for BStr { 346 type Target = [u8]; 347 348 #[inline] deref(&self) -> &[u8]349 fn deref(&self) -> &[u8] { 350 &self.bytes 351 } 352 } 353 354 impl ops::DerefMut for BStr { 355 #[inline] deref_mut(&mut self) -> &mut [u8]356 fn deref_mut(&mut self) -> &mut [u8] { 357 &mut self.bytes 358 } 359 } 360 361 impl ops::Index<usize> for BStr { 362 type Output = u8; 363 364 #[inline] index(&self, idx: usize) -> &u8365 fn index(&self, idx: usize) -> &u8 { 366 &self.as_bytes()[idx] 367 } 368 } 369 370 impl ops::Index<ops::RangeFull> for BStr { 371 type Output = BStr; 372 373 #[inline] index(&self, _: ops::RangeFull) -> &BStr374 fn index(&self, _: ops::RangeFull) -> &BStr { 375 self 376 } 377 } 378 379 impl ops::Index<ops::Range<usize>> for BStr { 380 type Output = BStr; 381 382 #[inline] index(&self, r: ops::Range<usize>) -> &BStr383 fn index(&self, r: ops::Range<usize>) -> &BStr { 384 BStr::new(&self.as_bytes()[r.start..r.end]) 385 } 386 } 387 388 impl ops::Index<ops::RangeInclusive<usize>> for BStr { 389 type Output = BStr; 390 391 #[inline] index(&self, r: ops::RangeInclusive<usize>) -> &BStr392 fn index(&self, r: ops::RangeInclusive<usize>) -> &BStr { 393 BStr::new(&self.as_bytes()[*r.start()..=*r.end()]) 394 } 395 } 396 397 impl ops::Index<ops::RangeFrom<usize>> for BStr { 398 type Output = BStr; 399 400 #[inline] index(&self, r: ops::RangeFrom<usize>) -> &BStr401 fn index(&self, r: ops::RangeFrom<usize>) -> &BStr { 402 BStr::new(&self.as_bytes()[r.start..]) 403 } 404 } 405 406 impl ops::Index<ops::RangeTo<usize>> for BStr { 407 type Output = BStr; 408 409 #[inline] index(&self, r: ops::RangeTo<usize>) -> &BStr410 fn index(&self, r: ops::RangeTo<usize>) -> &BStr { 411 BStr::new(&self.as_bytes()[..r.end]) 412 } 413 } 414 415 impl ops::Index<ops::RangeToInclusive<usize>> for BStr { 416 type Output = BStr; 417 418 #[inline] index(&self, r: ops::RangeToInclusive<usize>) -> &BStr419 fn index(&self, r: ops::RangeToInclusive<usize>) -> &BStr { 420 BStr::new(&self.as_bytes()[..=r.end]) 421 } 422 } 423 424 impl ops::IndexMut<usize> for BStr { 425 #[inline] index_mut(&mut self, idx: usize) -> &mut u8426 fn index_mut(&mut self, idx: usize) -> &mut u8 { 427 &mut self.bytes[idx] 428 } 429 } 430 431 impl ops::IndexMut<ops::RangeFull> for BStr { 432 #[inline] index_mut(&mut self, _: ops::RangeFull) -> &mut BStr433 fn index_mut(&mut self, _: ops::RangeFull) -> &mut BStr { 434 self 435 } 436 } 437 438 impl ops::IndexMut<ops::Range<usize>> for BStr { 439 #[inline] index_mut(&mut self, r: ops::Range<usize>) -> &mut BStr440 fn index_mut(&mut self, r: ops::Range<usize>) -> &mut BStr { 441 BStr::from_bytes_mut(&mut self.bytes[r.start..r.end]) 442 } 443 } 444 445 impl ops::IndexMut<ops::RangeInclusive<usize>> for BStr { 446 #[inline] index_mut(&mut self, r: ops::RangeInclusive<usize>) -> &mut BStr447 fn index_mut(&mut self, r: ops::RangeInclusive<usize>) -> &mut BStr { 448 BStr::from_bytes_mut(&mut self.bytes[*r.start()..=*r.end()]) 449 } 450 } 451 452 impl ops::IndexMut<ops::RangeFrom<usize>> for BStr { 453 #[inline] index_mut(&mut self, r: ops::RangeFrom<usize>) -> &mut BStr454 fn index_mut(&mut self, r: ops::RangeFrom<usize>) -> &mut BStr { 455 BStr::from_bytes_mut(&mut self.bytes[r.start..]) 456 } 457 } 458 459 impl ops::IndexMut<ops::RangeTo<usize>> for BStr { 460 #[inline] index_mut(&mut self, r: ops::RangeTo<usize>) -> &mut BStr461 fn index_mut(&mut self, r: ops::RangeTo<usize>) -> &mut BStr { 462 BStr::from_bytes_mut(&mut self.bytes[..r.end]) 463 } 464 } 465 466 impl ops::IndexMut<ops::RangeToInclusive<usize>> for BStr { 467 #[inline] index_mut(&mut self, r: ops::RangeToInclusive<usize>) -> &mut BStr468 fn index_mut(&mut self, r: ops::RangeToInclusive<usize>) -> &mut BStr { 469 BStr::from_bytes_mut(&mut self.bytes[..=r.end]) 470 } 471 } 472 473 impl AsRef<[u8]> for BStr { 474 #[inline] as_ref(&self) -> &[u8]475 fn as_ref(&self) -> &[u8] { 476 self.as_bytes() 477 } 478 } 479 480 impl AsRef<BStr> for [u8] { 481 #[inline] as_ref(&self) -> &BStr482 fn as_ref(&self) -> &BStr { 483 BStr::new(self) 484 } 485 } 486 487 impl AsRef<BStr> for str { 488 #[inline] as_ref(&self) -> &BStr489 fn as_ref(&self) -> &BStr { 490 BStr::new(self) 491 } 492 } 493 494 impl AsMut<[u8]> for BStr { 495 #[inline] as_mut(&mut self) -> &mut [u8]496 fn as_mut(&mut self) -> &mut [u8] { 497 &mut self.bytes 498 } 499 } 500 501 impl AsMut<BStr> for [u8] { 502 #[inline] as_mut(&mut self) -> &mut BStr503 fn as_mut(&mut self) -> &mut BStr { 504 BStr::new_mut(self) 505 } 506 } 507 508 impl<'a> Default for &'a BStr { default() -> &'a BStr509 fn default() -> &'a BStr { 510 BStr::from_bytes(b"") 511 } 512 } 513 514 impl<'a> Default for &'a mut BStr { default() -> &'a mut BStr515 fn default() -> &'a mut BStr { 516 BStr::from_bytes_mut(&mut []) 517 } 518 } 519 520 impl<'a> From<&'a [u8]> for &'a BStr { 521 #[inline] from(s: &'a [u8]) -> &'a BStr522 fn from(s: &'a [u8]) -> &'a BStr { 523 BStr::from_bytes(s) 524 } 525 } 526 527 impl<'a> From<&'a str> for &'a BStr { 528 #[inline] from(s: &'a str) -> &'a BStr529 fn from(s: &'a str) -> &'a BStr { 530 BStr::from_bytes(s.as_bytes()) 531 } 532 } 533 534 #[cfg(feature = "std")] 535 impl<'a> From<&'a BStr> for Cow<'a, BStr> { 536 #[inline] from(s: &'a BStr) -> Cow<'a, BStr>537 fn from(s: &'a BStr) -> Cow<'a, BStr> { 538 Cow::Borrowed(s) 539 } 540 } 541 542 impl Eq for BStr {} 543 544 impl PartialEq<BStr> for BStr { 545 #[inline] eq(&self, other: &BStr) -> bool546 fn eq(&self, other: &BStr) -> bool { 547 self.as_bytes() == other.as_bytes() 548 } 549 } 550 551 impl_partial_eq!(BStr, [u8]); 552 impl_partial_eq!(BStr, &'a [u8]); 553 impl_partial_eq!(BStr, str); 554 impl_partial_eq!(BStr, &'a str); 555 556 #[cfg(feature = "std")] 557 impl_partial_eq!(BStr, Vec<u8>); 558 #[cfg(feature = "std")] 559 impl_partial_eq!(&'a BStr, Vec<u8>); 560 #[cfg(feature = "std")] 561 impl_partial_eq!(BStr, String); 562 #[cfg(feature = "std")] 563 impl_partial_eq!(&'a BStr, String); 564 #[cfg(feature = "std")] 565 impl_partial_eq_cow!(&'a BStr, Cow<'a, BStr>); 566 #[cfg(feature = "std")] 567 impl_partial_eq_cow!(&'a BStr, Cow<'a, str>); 568 #[cfg(feature = "std")] 569 impl_partial_eq_cow!(&'a BStr, Cow<'a, [u8]>); 570 571 impl PartialOrd for BStr { 572 #[inline] partial_cmp(&self, other: &BStr) -> Option<Ordering>573 fn partial_cmp(&self, other: &BStr) -> Option<Ordering> { 574 PartialOrd::partial_cmp(self.as_bytes(), other.as_bytes()) 575 } 576 } 577 578 impl Ord for BStr { 579 #[inline] cmp(&self, other: &BStr) -> Ordering580 fn cmp(&self, other: &BStr) -> Ordering { 581 self.partial_cmp(other).unwrap() 582 } 583 } 584 585 impl_partial_ord!(BStr, [u8]); 586 impl_partial_ord!(BStr, &'a [u8]); 587 impl_partial_ord!(BStr, str); 588 impl_partial_ord!(BStr, &'a str); 589 590 #[cfg(feature = "std")] 591 impl_partial_ord!(BStr, Vec<u8>); 592 #[cfg(feature = "std")] 593 impl_partial_ord!(&'a BStr, Vec<u8>); 594 #[cfg(feature = "std")] 595 impl_partial_ord!(BStr, String); 596 #[cfg(feature = "std")] 597 impl_partial_ord!(&'a BStr, String); 598 } 599 600 #[cfg(feature = "serde1-nostd")] 601 mod bstr_serde { 602 use core::fmt; 603 604 use serde::{ 605 de::Error, de::Visitor, Deserialize, Deserializer, Serialize, 606 Serializer, 607 }; 608 609 use bstr::BStr; 610 611 impl Serialize for BStr { 612 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,613 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 614 where 615 S: Serializer, 616 { 617 serializer.serialize_bytes(self.as_bytes()) 618 } 619 } 620 621 impl<'a, 'de: 'a> Deserialize<'de> for &'a BStr { 622 #[inline] deserialize<D>(deserializer: D) -> Result<&'a BStr, D::Error> where D: Deserializer<'de>,623 fn deserialize<D>(deserializer: D) -> Result<&'a BStr, D::Error> 624 where 625 D: Deserializer<'de>, 626 { 627 struct BStrVisitor; 628 629 impl<'de> Visitor<'de> for BStrVisitor { 630 type Value = &'de BStr; 631 632 fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { 633 f.write_str("a borrowed byte string") 634 } 635 636 #[inline] 637 fn visit_borrowed_bytes<E: Error>( 638 self, 639 value: &'de [u8], 640 ) -> Result<&'de BStr, E> { 641 Ok(BStr::new(value)) 642 } 643 644 #[inline] 645 fn visit_borrowed_str<E: Error>( 646 self, 647 value: &'de str, 648 ) -> Result<&'de BStr, E> { 649 Ok(BStr::new(value)) 650 } 651 } 652 653 deserializer.deserialize_bytes(BStrVisitor) 654 } 655 } 656 } 657 658 #[cfg(feature = "serde1")] 659 mod bstring_serde { 660 use std::cmp; 661 use std::fmt; 662 663 use serde::{ 664 de::Error, de::SeqAccess, de::Visitor, Deserialize, Deserializer, 665 Serialize, Serializer, 666 }; 667 668 use bstring::BString; 669 670 impl Serialize for BString { 671 #[inline] serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,672 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 673 where 674 S: Serializer, 675 { 676 serializer.serialize_bytes(self.as_bytes()) 677 } 678 } 679 680 impl<'de> Deserialize<'de> for BString { 681 #[inline] deserialize<D>(deserializer: D) -> Result<BString, D::Error> where D: Deserializer<'de>,682 fn deserialize<D>(deserializer: D) -> Result<BString, D::Error> 683 where 684 D: Deserializer<'de>, 685 { 686 struct BStringVisitor; 687 688 impl<'de> Visitor<'de> for BStringVisitor { 689 type Value = BString; 690 691 fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { 692 f.write_str("a byte string") 693 } 694 695 #[inline] 696 fn visit_seq<V: SeqAccess<'de>>( 697 self, 698 mut visitor: V, 699 ) -> Result<BString, V::Error> { 700 let len = cmp::min(visitor.size_hint().unwrap_or(0), 256); 701 let mut bytes = Vec::with_capacity(len); 702 while let Some(v) = visitor.next_element()? { 703 bytes.push(v); 704 } 705 Ok(BString::from(bytes)) 706 } 707 708 #[inline] 709 fn visit_bytes<E: Error>( 710 self, 711 value: &[u8], 712 ) -> Result<BString, E> { 713 Ok(BString::from(value)) 714 } 715 716 #[inline] 717 fn visit_byte_buf<E: Error>( 718 self, 719 value: Vec<u8>, 720 ) -> Result<BString, E> { 721 Ok(BString::from(value)) 722 } 723 724 #[inline] 725 fn visit_str<E: Error>( 726 self, 727 value: &str, 728 ) -> Result<BString, E> { 729 Ok(BString::from(value)) 730 } 731 732 #[inline] 733 fn visit_string<E: Error>( 734 self, 735 value: String, 736 ) -> Result<BString, E> { 737 Ok(BString::from(value)) 738 } 739 } 740 741 deserializer.deserialize_byte_buf(BStringVisitor) 742 } 743 } 744 } 745 746 #[cfg(test)] 747 mod bstring_arbitrary { 748 use bstring::BString; 749 750 use quickcheck::{Arbitrary, Gen}; 751 752 impl Arbitrary for BString { arbitrary<G: Gen>(g: &mut G) -> BString753 fn arbitrary<G: Gen>(g: &mut G) -> BString { 754 BString::from(Vec::<u8>::arbitrary(g)) 755 } 756 shrink(&self) -> Box<dyn Iterator<Item = BString>>757 fn shrink(&self) -> Box<dyn Iterator<Item = BString>> { 758 Box::new(self.bytes.shrink().map(BString::from)) 759 } 760 } 761 } 762