internet 0.1.0

// //! LABEL
// //!
// //! > description

// use crate::{Buf, BufError, BufMut, BufResult, Codec, Cursor, ietf::quicv1::VarInt};

// /// A Frame Types following [Section 12.4].
// ///
// /// The `Type` field values of all frames.
// ///
// /// [Section 12.4](https://datatracker.ietf.org/doc/html/rfc9000#section-12.4).
// #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
// #[repr(u64)]
// pub enum FrameType {
//   /// (PADDING frame)[PaddingFrame].
//   Padding = 0x00,

//   /// (PING frame)[PaddingFrame].
//   Ping = 0x01,

//   /// (PING frame)[PaddingFrame].
//   Ack = 0x02,

//   /// (PING frame)[PaddingFrame].
//   ResetStream = 0x04,

//   /// (PING frame)[PaddingFrame].
//   StopSending = 0x05,

//   /// (PING frame)[PaddingFrame].
//   Crypto = 0x06,

//   /// (PING frame)[PaddingFrame].
//   NewToken = 0x07,

//   /// (PING frame)[PaddingFrame].
//   Stream = 0x08,

//   /// The (MAX_DATA frame)[MaxDataFrame].
//   MaxData = 0x10,

//   /// The (MaxStreamData frame)[MaxStreamDataFrame].
//   MaxStreamData = 0x11,

//   /// The (MaxStreams frame)[MaxStreamsFrame].
//   MaxStreams = 0x12,

//   /// The (DataBlocked frame)[DataBlockedFrame].
//   DataBlocked = 0x14,

//   /// The (StreamDataBlocked frame)[StreamDataBlockedFrame].
//   StreamDataBlocked = 0x15,

//   /// The (StreamsBlocked frame)[StreamsBlockedFrame].
//   StreamsBlocked = 0x16,

//   /// The (NewConnectionId frame)[NewConnectionIdFrame].
//   NewConnectionId = 0x18,

//   /// The (RetireConnectionId frame)[RetireConnectionIdFrame].
//   RetireConnectionId = 0x19,

//   /// The (PathChallenge frame)[PathChallengeFrame].
//   PathChallenge = 0x1a,

//   /// The (PathResponse frame)[PathResponseFrame].
//   PathResponse = 0x1b,

//   /// The (ConnectionClose frame)[ConnectionCloseFrame].
//   ConnectionClose = 0x1c,

//   /// The (HandshakeDone frame)[HandshakeDoneFrame].
//   HandshakeDone = 0x1e,
// }

// impl Codec for FrameType {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     (*self as u8).encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     match u8::decode(reader, ())? {
//       x if x == (Self::Padding as u8) => Ok(Self::Padding),
//       _ => Err(BufError::UnexpectedValue),
//     }
//   }
// }

// /// A frame following [Section 7.1].
// ///
// /// > descrption
// ///
// /// [Section 7.1]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.1
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct Frame {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for Frame {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A DATA frame following [Section 7.2.1].
// ///
// /// > descrption
// ///
// /// [Section 7.2.1]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.1
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct DataFrame {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for DataFrame {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A HEADERS frame following [Section 7.2.2].
// ///
// /// > descrption
// ///
// /// [Section 7.2.2]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.2
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct HeadersFrame {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for HeadersFrame {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A CANCEL_PUSH frame following [Section 7.2.3].
// ///
// /// > descrption
// ///
// /// [Section 7.2.3]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.3
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct CancelPush {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for CancelPush {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A SETTINGS frame following [Section 7.2.4].
// ///
// /// > descrption
// ///
// /// [Section 7.2.4]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.4
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct SettingsFrame {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for SettingsFrame {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A PUSH_PROMISE frame following [Section 7.2.5].
// ///
// /// > descrption
// ///
// /// [Section 7.2.5]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.5
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct PushPromise {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for PushPromise {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A GOAWAY frame following [Section 7.2.6].
// ///
// /// > descrption
// ///
// /// [Section 7.2.6]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.6
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct Goaway {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for Goaway {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// A MAX_PUSH_ID frame following [Section 7.2.7].
// ///
// /// > descrption
// ///
// /// [Section 7.2.7]: https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.7
// #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct MaxPushId {
//   ///
//   pub r#type: VarInt,
//   ///
//   pub frame_payload: Vec<u8>,
// }

// impl Codec for MaxPushId {
//   fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
//     self.r#type.encode(writer, ())?;
//     self.frame_payload.encode(writer, ())
//   }

//   fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
//     let r#type = VarInt::decode(reader, ())?;
//     let _length = VarInt::decode(reader, ())?;
//     let frame_payload = Vec::decode(reader, ())?;
//     Ok(Self {
//       r#type,
//       frame_payload,
//     })
//   }
// }

// /// Error Codes of the [CONNECTION_CLOSE frame] by [Section 8.1].
// ///
// /// > description
// ///
// /// [CONNECTION_CLOSE frame]: ConnectionCloseFrame
// /// [Section 8.1]: https://datatracker.ietf.org/doc/html/rfc9114#section-8.1
// #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
// #[repr(u64)]
// pub enum ErrorCode {
//   /// NO_ERROR 0x00: No error
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   H3NoError = 0x0100,

//   /// INTERNAL_ERROR 0x01: Implementation error
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   H3GeneralProtocolError = 0x0101,

//   /// CONNECTION_REFUSED 0x02: Server refuses a connection
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   H3InternalError = 0x0102,

//   /// FLOW_CONTROL_ERROR 0x03: Flow control error
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   FlowControlError = 0x0103,

//   /// STREAM_LIMIT_ERROR 0x04: Too many streams opened
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   StreamLimitError = 0x0104,

//   /// STREAM_STATE_ERROR 0x05: Frame received in invalid stream state
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   StreamStateError = 0x0105,

//   /// FINAL_SIZE_ERROR 0x06: Change to final size
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   FinalSizeError = 0x0106,

//   /// FRAME_ENCODING_ERROR 0x07: Frame encoding error
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   FrameEncodingError = 0x0107,

//   /// TRANSPORT_PARAMETER_ERROR 0x08: Error in transport parameters
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   TransportParameterError = 0x0108,

//   /// CONNECTION_ID_LIMIT_ERROR 0x09: Too many connection IDs received
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   ConnectionIdLimitError = 0x0109,

//   /// PROTOCOL_VIOLATION 0x0a: Generic protocol violation
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   ProtocolViolation = 0x010a,

//   /// INVALID_TOKEN 0x0b: Invalid Token received
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   InvalidToken = 0x010b,

//   /// APPLICATION_ERROR 0x0c: Application error
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   ApplicationError = 0x010c,

//   /// CRYPTO_BUFFER_EXCEEDED 0x0d: CRYPTO data buffer overflowed
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   CryptoBufferExceeded = 0x010d,

//   /// KEY_UPDATE_ERROR 0x0e: Invalid packet protection update
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   KeyUpdateError = 0x010e,

//   /// AEAD_LIMIT_REACHED 0x0f: Excessive use of packet protection keys
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   AeadLimitReached = 0x010f,

//   /// NO_VIABLE_PATH 0x10: No viable network path exists
//   /// [Section 8.1](https://datatracker.ietf.org/doc/html/rfc9114#section-8.1)
//   NoViablePath = 0x0110,
// }

// impl From<ErrorCode> for VarInt {
//   fn from(value: ErrorCode) -> Self {
//     Self(value as u64)
//   }
// }

// impl TryFrom<VarInt> for ErrorCode {
//   type Error = BufError;

//   fn try_from(value: VarInt) -> Result<Self, Self::Error> {
//     Self::try_from(value.into_inner())
//   }
// }

// impl From<ErrorCode> for u64 {
//   fn from(value: ErrorCode) -> Self {
//     value as u64
//   }
// }

// impl TryFrom<u64> for ErrorCode {
//   type Error = BufError;

//   fn try_from(value: u64) -> Result<Self, Self::Error> {
//     match value {
//       x if x == Self::H3NoError as u64 => Ok(Self::H3NoError),
//       x if x == Self::H3GeneralProtocolError as u64 => Ok(Self::H3GeneralProtocolError),
//       x if x == Self::H3InternalError as u64 => Ok(Self::H3InternalError),
//       x if x == Self::FlowControlError as u64 => Ok(Self::FlowControlError),
//       x if x == Self::StreamLimitError as u64 => Ok(Self::StreamLimitError),
//       x if x == Self::StreamStateError as u64 => Ok(Self::StreamStateError),
//       x if x == Self::FinalSizeError as u64 => Ok(Self::FinalSizeError),
//       x if x == Self::FrameEncodingError as u64 => Ok(Self::FrameEncodingError),
//       x if x == Self::TransportParameterError as u64 => Ok(Self::TransportParameterError),
//       x if x == Self::ConnectionIdLimitError as u64 => Ok(Self::ConnectionIdLimitError),
//       x if x == Self::ProtocolViolation as u64 => Ok(Self::ProtocolViolation),
//       x if x == Self::InvalidToken as u64 => Ok(Self::InvalidToken),
//       x if x == Self::ApplicationError as u64 => Ok(Self::ApplicationError),
//       x if x == Self::CryptoBufferExceeded as u64 => Ok(Self::CryptoBufferExceeded),
//       x if x == Self::KeyUpdateError as u64 => Ok(Self::KeyUpdateError),
//       x if x == Self::AeadLimitReached as u64 => Ok(Self::AeadLimitReached),
//       x if x == Self::NoViablePath as u64 => Ok(Self::NoViablePath),
//       _ => Err(BufError::UnexpectedValue),
//     }
//   }
// }

// #[cfg(test)]
// mod tests {
//   #[test]
//   fn test() {}
// }