changelog shortlog graph tags branches changeset files revisions annotate raw help

Mercurial > core / rust/lib/net/src/codec/dm/build.rs

changeset 698: 96958d3eb5b0
parent: c7165d93a9eb
author: Richard Westhaver <ellis@rwest.io>
date: Fri, 04 Oct 2024 22:04:59 -0400
permissions: -rw-r--r--
description: fixes 
     1 //! builder for dm protocol prefab
     2 use tokio_util::codec::{Framed, FramedRead, FramedWrite};
     3 use super::{DecodeState, DmCodec};
     4 use std::cmp;
     5 
     6 use tokio::io::{AsyncRead, AsyncWrite};
     7 
     8 // use bytes::{Buf, BufMut, Bytes, BytesMut};
     9 
    10 #[derive(Debug, Clone, Copy)]
    11 pub struct Builder {
    12     // Maximum frame length
    13     max_frame_len: usize,
    14     // Number of bytes representing the field length
    15     length_field_len: usize,
    16     // Number of bytes in the header before the length field
    17     length_field_offset: usize,
    18     // Adjust the length specified in the header field by this amount
    19     length_adjustment: isize,
    20     // Total number of bytes to skip before reading the payload, if not set,
    21     // `length_field_len + length_field_offset`
    22     num_skip: Option<usize>,
    23     // Length field byte order (little or big endian)
    24     length_field_is_big_endian: bool,
    25 }
    26 
    27 impl Builder {
    28     pub fn new() -> Self {
    29         Builder {
    30             // Default max frame length of 4KB
    31             max_frame_len: 4 * 1_024,
    32             // Default byte length of 4
    33             length_field_len: 4,
    34             // Default to the header field being at the start of the header.
    35             length_field_offset: 0,
    36             length_adjustment: 0,
    37             // Total number of bytes to skip before reading the payload, if not set,
    38             // `length_field_len + length_field_offset`
    39             num_skip: None,
    40             // Default to reading the length field in network (big) endian.
    41             length_field_is_big_endian: true,            
    42         }
    43     }
    44 
    45     pub fn big_endian(&mut self) -> &mut Self {
    46         self.length_field_is_big_endian = true;
    47         self
    48     }
    49 
    50     pub fn native_endian(&mut self) -> &mut Self {
    51         if cfg!(target_endian = "big") {
    52             self.big_endian()
    53         } else {
    54             self.native_endian()
    55         }
    56     }    
    57 
    58     pub fn max_frame_length(&mut self, val: usize) -> &mut Self {
    59         self.max_frame_len = val;
    60         self
    61     }    
    62 
    63     pub fn length_field_length(&mut self, val: usize) -> &mut Self {
    64         assert!(val > 0 && val <= 8, "invalid length field length");
    65         self.length_field_len = val;
    66         self
    67     }
    68 
    69     pub fn length_field_offset(&mut self, val: usize) -> &mut Self {
    70         self.length_field_offset = val;
    71         self
    72     }
    73 
    74     pub fn length_adjustment(&mut self, val: isize) -> &mut Self {
    75         self.length_adjustment = val;
    76         self
    77     }
    78 
    79     pub fn num_skip(&mut self, val: usize) -> &mut Self {
    80         self.num_skip = Some(val);
    81         self
    82     }
    83 
    84     pub fn new_codec(&self) -> DmCodec {
    85         DmCodec {
    86             builder: *self,
    87             state: DecodeState::Head,
    88         }
    89     }
    90 
    91     pub fn new_read<T>(&self, upstream: T) -> FramedRead<T, DmCodec>
    92     where
    93         T: AsyncRead,
    94     {
    95         FramedRead::new(upstream, self.new_codec())
    96     }
    97 
    98     pub fn new_write<T>(&self, inner: T) -> FramedWrite<T, DmCodec>
    99     where
   100         T: AsyncWrite,
   101     {
   102         FramedWrite::new(inner, self.new_codec())
   103     }
   104 
   105     pub fn new_framed<T>(&self, inner: T) -> Framed<T, DmCodec>
   106     where
   107         T: AsyncRead + AsyncWrite,
   108     {
   109         Framed::new(inner, self.new_codec())
   110     }
   111 
   112     fn num_head_bytes(&self) -> usize {
   113         let num = self.length_field_offset + self.length_field_len;
   114         cmp::max(num, self.num_skip.unwrap_or(0))
   115     }
   116 
   117     fn get_num_skip(&self) -> usize {
   118         self.num_skip
   119             .unwrap_or(self.length_field_offset + self.length_field_len)
   120     }
   121 }
   122 
   123 impl Default for Builder {
   124     fn default() -> Self {
   125         Self::new()
   126     }
   127 }