Lines Matching full:packet
116 /// struct Packet {
121 /// // These bytes encode a `Packet`.
124 /// let packet = Packet::ref_from_bytes(bytes).unwrap();
126 /// assert_eq!(packet.length, 4);
127 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
129 /// // Attempt to split `packet` at `length`.
130 /// let split = packet.split_at(packet.length as usize).unwrap();
132 /// // Use the `Immutable` bound on `Packet` to prove that it's okay to
133 /// // return concurrent references to `packet` and `rest`.
134 /// let (packet, rest) = split.via_immutable();
136 /// assert_eq!(packet.length, 4);
137 /// assert_eq!(packet.body, [1, 2, 3, 4]);
204 /// struct Packet<B: ?Sized> {
209 /// // These bytes encode a `Packet`.
212 /// let packet = Packet::<[u8]>::mut_from_bytes(bytes).unwrap();
214 /// assert_eq!(packet.length, 4);
215 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
218 /// // Attempt to split `packet` at `length`.
219 /// let split = packet.split_at_mut(packet.length as usize).unwrap();
221 /// // Use the `IntoBytes` bound on `Packet` to prove that it's okay to
222 /// // return concurrent references to `packet` and `rest`.
223 /// let (packet, rest) = split.via_into_bytes();
225 /// assert_eq!(packet.length, 4);
226 /// assert_eq!(packet.body, [1, 2, 3, 4]);
232 /// assert_eq!(packet.length, 4);
233 /// assert_eq!(packet.body, [1, 2, 3, 4, 0, 0, 0, 0, 0]);
325 /// struct Packet {
330 /// // These bytes encode a `Packet`.
333 /// let packet = Packet::ref_from_bytes(bytes).unwrap();
335 /// assert_eq!(packet.length, 4);
336 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
338 /// // Attempt to split `packet` at `length`.
339 /// let split = packet.split_at(packet.length as usize).unwrap();
341 /// // Use the `Immutable` bound on `Packet` to prove that it's okay to
342 /// // return concurrent references to `packet` and `rest`.
343 /// let (packet, rest) = split.via_immutable();
345 /// assert_eq!(packet.length, 4);
346 /// assert_eq!(packet.body, [1, 2, 3, 4]);
388 /// struct Packet<B: ?Sized> {
393 /// // These bytes encode a `Packet`.
396 /// let packet = Packet::<[u8]>::ref_from_bytes(bytes).unwrap();
398 /// assert_eq!(packet.length, 4);
399 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
401 /// // Attempt to split `packet` at `length`.
402 /// let split = packet.split_at(packet.length as usize).unwrap();
404 /// // Use the `IntoBytes` bound on `Packet` to prove that it's okay to
405 /// // return concurrent references to `packet` and `rest`.
406 /// let (packet, rest) = split.via_into_bytes();
408 /// assert_eq!(packet.length, 4);
409 /// assert_eq!(packet.body, [1, 2, 3, 4]);
437 /// struct Packet {
442 /// // These bytes encode a `Packet`.
445 /// let packet = Packet::ref_from_bytes(bytes).unwrap();
447 /// assert_eq!(packet.length, 4);
448 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
450 /// // Attempt to split `packet` at `length`.
451 /// let split = packet.split_at(packet.length as usize).unwrap();
453 /// // Use the `Unaligned` bound on `Packet` to prove that it's okay to
454 /// // return concurrent references to `packet` and `rest`.
455 /// let (packet, rest) = split.via_unaligned();
457 /// assert_eq!(packet.length, 4);
458 /// assert_eq!(packet.body, [1, 2, 3, 4]);
492 /// struct Packet {
497 /// // These bytes encode a `Packet`.
506 /// let packet = Packet::ref_from_bytes(bytes.as_bytes()).unwrap();
508 /// assert_eq!(packet.length, 4);
509 /// assert_eq!(packet.body, [0, 1, 0, 2, 0, 3, 0, 4]);
511 /// // Attempt to split `packet` at `length`.
512 /// let split = packet.split_at(packet.length.into()).unwrap();
515 /// // references to `packet` and `rest`.
516 /// let (packet, rest) = split.via_runtime_check().unwrap();
518 /// assert_eq!(packet.length, 4);
519 /// assert_eq!(packet.body, [0, 1, 0, 2]);
522 /// // Attempt to split `packet` at `length - 1`.
523 /// let idx = packet.length.get() - 1;
524 /// let split = packet.split_at(idx as usize).unwrap();
527 /// // to return concurrent references to `packet` and `rest`. Note that
623 /// struct Packet<B: ?Sized> {
628 /// // These bytes encode a `Packet`.
631 /// let packet = Packet::<[u8]>::mut_from_bytes(bytes).unwrap();
633 /// assert_eq!(packet.length, 4);
634 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
637 /// // Attempt to split `packet` at `length`.
638 /// let split = packet.split_at_mut(packet.length as usize).unwrap();
640 /// // Use the `IntoBytes` bound on `Packet` to prove that it's okay to
641 /// // return concurrent references to `packet` and `rest`.
642 /// let (packet, rest) = split.via_into_bytes();
644 /// assert_eq!(packet.length, 4);
645 /// assert_eq!(packet.body, [1, 2, 3, 4]);
651 /// assert_eq!(packet.length, 4);
652 /// assert_eq!(packet.body, [1, 2, 3, 4, 0, 0, 0, 0, 0]);
679 /// struct Packet<B: ?Sized> {
684 /// // These bytes encode a `Packet`.
687 /// let packet = Packet::<[u8]>::mut_from_bytes(bytes).unwrap();
689 /// assert_eq!(packet.length, 4);
690 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
693 /// // Attempt to split `packet` at `length`.
694 /// let split = packet.split_at_mut(packet.length as usize).unwrap();
696 /// // Use the `Unaligned` bound on `Packet` to prove that it's okay to
697 /// // return concurrent references to `packet` and `rest`.
698 /// let (packet, rest) = split.via_unaligned();
700 /// assert_eq!(packet.length, 4);
701 /// assert_eq!(packet.body, [1, 2, 3, 4]);
707 /// assert_eq!(packet.length, 4);
708 /// assert_eq!(packet.body, [1, 2, 3, 4, 0, 0, 0, 0, 0]);
737 /// struct Packet<B: ?Sized> {
742 /// // These bytes encode a `Packet`.
745 /// let packet = Packet::<[u8]>::mut_from_bytes(bytes).unwrap();
747 /// assert_eq!(packet.length, 4);
748 /// assert_eq!(packet.body, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
751 /// // Attempt to split `packet` at `length`.
752 /// let split = packet.split_at_mut(packet.length as usize).unwrap();
755 /// // references to `packet` and `rest`.
756 /// let (packet, rest) = split.via_runtime_check().unwrap();
758 /// assert_eq!(packet.length, 4);
759 /// assert_eq!(packet.body, [1, 2, 3, 4]);
765 /// assert_eq!(packet.length, 4);
766 /// assert_eq!(packet.body, [1, 2, 3, 4, 0, 0, 0, 0, 0]);
1054 struct Packet { in test_split_at_via_methods() struct
1060 let packet = Packet::ref_from_bytes(&arr[..]).unwrap(); in test_split_at_via_methods() localVariable
1062 let split1 = packet.split_at(2).unwrap(); in test_split_at_via_methods()
1067 let split2 = packet.split_at(2).unwrap(); in test_split_at_via_methods()
1077 struct Packet { in test_split_at_via_unaligned() struct
1083 let packet = Packet::ref_from_bytes(&arr[..]).unwrap(); in test_split_at_via_unaligned() localVariable
1085 let split = packet.split_at(2).unwrap(); in test_split_at_via_unaligned()