use std::ops::Range;
use std::sync::Arc;
use smallvec::{Array, SmallVec};
use crate::internal_protocol::{ProtocolError, Result, StableOwnerLease};
pub(crate) const INLINE_SEGMENTS: usize = 2;
const INLINE_REQUEST_PREFIX_BYTES: usize = 64;
pub type OwnedFrame = SegmentFrame<[WireSegment; INLINE_SEGMENTS]>;
#[derive(Debug, Eq, PartialEq)]
pub struct OwnedRequestFrame {
prefix: RequestPrefix,
suffix: OwnedFrame,
encoded_len: usize,
}
impl OwnedRequestFrame {
pub(crate) fn from_parts(
prefix: RequestPrefix,
suffix: SmallVec<[WireSegment; INLINE_SEGMENTS]>,
) -> Result<Self> {
let suffix = OwnedFrame::from_segments(suffix)?;
let encoded_len = prefix
.as_slice()
.len()
.checked_add(suffix.len())
.ok_or(ProtocolError::FrameLengthOverflow)?;
Ok(Self {
prefix,
suffix,
encoded_len,
})
}
pub fn segments(&self) -> impl Iterator<Item = &[u8]> {
std::iter::once(self.prefix.as_slice())
.chain(self.suffix.segments().iter().map(WireSegment::as_slice))
.filter(|segment| !segment.is_empty())
}
pub const fn len(&self) -> usize {
self.encoded_len
}
pub const fn is_empty(&self) -> bool {
self.encoded_len == 0
}
pub fn clone_owned(&self) -> Result<Self> {
let bytes = self.segments().flatten().copied().collect::<Vec<_>>();
let mut prefix = RequestPrefix::with_capacity(bytes.len());
prefix.try_extend_from_slice(&bytes)?;
Self::from_parts(prefix, SmallVec::new())
}
}
const _: () = assert!(std::mem::size_of::<OwnedRequestFrame>() <= 200);
#[derive(Debug, Eq, PartialEq)]
pub(crate) enum RequestPrefix {
Inline {
bytes: [u8; INLINE_REQUEST_PREFIX_BYTES],
len: u8,
},
Owned(Vec<u8>),
}
impl RequestPrefix {
pub(crate) fn with_capacity(capacity: usize) -> Self {
if capacity <= INLINE_REQUEST_PREFIX_BYTES {
Self::Inline {
bytes: [0; INLINE_REQUEST_PREFIX_BYTES],
len: 0,
}
} else {
Self::Owned(Vec::with_capacity(capacity))
}
}
pub(crate) fn try_extend_from_slice(&mut self, suffix: &[u8]) -> Result<()> {
match self {
Self::Inline { bytes, len } => {
let start = usize::from(*len);
let end = start
.checked_add(suffix.len())
.ok_or(ProtocolError::FrameLengthOverflow)?;
if end > INLINE_REQUEST_PREFIX_BYTES {
return Err(ProtocolError::FrameLength {
expected: INLINE_REQUEST_PREFIX_BYTES,
actual: end,
});
}
bytes[start..end].copy_from_slice(suffix);
*len = u8::try_from(end).expect("inline request prefix length fits in u8");
}
Self::Owned(bytes) => {
let required = bytes
.len()
.checked_add(suffix.len())
.ok_or(ProtocolError::FrameLengthOverflow)?;
if required > bytes.capacity() {
return Err(ProtocolError::FrameLength {
expected: bytes.capacity(),
actual: required,
});
}
bytes.extend_from_slice(suffix);
}
}
Ok(())
}
pub(crate) fn as_slice(&self) -> &[u8] {
match self {
Self::Inline { bytes, len } => &bytes[..usize::from(*len)],
Self::Owned(bytes) => bytes,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct OwnedRange {
buffer: Vec<u8>,
range: Range<usize>,
}
impl OwnedRange {
pub fn new(buffer: Vec<u8>, range: Range<usize>) -> Option<Self> {
(range.start <= range.end && range.end <= buffer.len()).then_some(Self { buffer, range })
}
pub fn whole(buffer: Vec<u8>) -> Self {
let end = buffer.len();
Self {
buffer,
range: 0..end,
}
}
pub fn as_slice(&self) -> &[u8] {
self.buffer
.get(self.range.clone())
.expect("owned byte range remains within its buffer")
}
pub fn len(&self) -> usize {
self.range.len()
}
pub fn is_empty(&self) -> bool {
self.range.is_empty()
}
pub fn into_subrange(self, range: Range<usize>) -> std::result::Result<Self, Self> {
if range.start > range.end || range.end > self.range.len() {
return Err(self);
}
let (buffer, owner_range) = self.into_parts();
Ok(Self {
buffer,
range: (owner_range.start + range.start)..(owner_range.start + range.end),
})
}
pub fn into_parts(self) -> (Vec<u8>, Range<usize>) {
(self.buffer, self.range)
}
}
impl From<Vec<u8>> for OwnedRange {
fn from(buffer: Vec<u8>) -> Self {
Self::whole(buffer)
}
}
impl AsRef<[u8]> for OwnedRange {
fn as_ref(&self) -> &[u8] {
self.as_slice()
}
}
#[derive(Debug, Default, Eq, PartialEq)]
pub struct InlineBytes(SmallVec<[u8; 32]>);
impl InlineBytes {
pub const fn new() -> Self {
Self(SmallVec::new_const())
}
pub fn try_extend_from_slice(&mut self, value: &[u8]) -> Result<()> {
let size = self
.0
.len()
.checked_add(value.len())
.ok_or(ProtocolError::FrameLengthOverflow)?;
if size > self.0.inline_size() {
return Err(ProtocolError::ValueTooLarge {
size,
maximum: self.0.inline_size(),
});
}
self.0.extend_from_slice(value);
Ok(())
}
pub fn as_slice(&self) -> &[u8] {
&self.0
}
}
pub trait StableByteOwner: Send + Sync + 'static {
fn as_bytes(&self) -> &[u8];
}
pub use StableByteOwner as WireByteOwner;
pub struct StableBytes {
owner: StableBytesOwner,
}
enum StableBytesOwner {
Shared {
owner: Arc<dyn StableByteOwner>,
range: Range<usize>,
},
External {
owner: Box<dyn StableByteOwner>,
len: usize,
},
Pooled {
lease: StableOwnerLease,
len: usize,
},
}
const _: () = assert!(std::mem::size_of::<StableBytes>() <= 40);
impl StableBytes {
pub fn new(owner: impl StableByteOwner) -> Self {
let len = owner.as_bytes().len();
Self {
owner: StableBytesOwner::External {
owner: Box::new(owner),
len,
},
}
}
pub fn from_shared<T>(owner: Arc<T>) -> Self
where
T: StableByteOwner,
{
let len = owner.as_bytes().len();
Self::from_shared_range(owner, 0..len)
.expect("a shared owner's complete byte range is valid")
}
pub fn from_shared_range<T>(owner: Arc<T>, range: Range<usize>) -> Option<Self>
where
T: StableByteOwner,
{
(range.start <= range.end && range.end <= owner.as_bytes().len()).then(|| Self {
owner: StableBytesOwner::Shared { owner, range },
})
}
pub fn from_pooled(lease: StableOwnerLease) -> Self {
let len = lease.as_bytes().len();
Self {
owner: StableBytesOwner::Pooled { lease, len },
}
}
pub fn as_slice(&self) -> &[u8] {
match &self.owner {
StableBytesOwner::Shared { owner, range } => owner
.as_bytes()
.get(range.clone())
.expect("stable byte owner changed its visible length"),
StableBytesOwner::External { owner, len } => {
let bytes = owner.as_bytes();
assert_eq!(
bytes.len(),
*len,
"stable byte owner changed its visible length"
);
bytes
}
StableBytesOwner::Pooled { lease, len } => {
let bytes = lease.as_bytes();
assert_eq!(
bytes.len(),
*len,
"stable byte owner pool changed its visible length"
);
bytes
}
}
}
}
impl StableByteOwner for Vec<u8> {
fn as_bytes(&self) -> &[u8] {
self
}
}
impl std::fmt::Debug for StableBytes {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_tuple("StableBytes")
.field(&self.as_slice())
.finish()
}
}
impl PartialEq for StableBytes {
fn eq(&self, other: &Self) -> bool {
self.as_slice() == other.as_slice()
}
}
impl Eq for StableBytes {}
pub struct ExternalWireBytes(StableBytes);
impl ExternalWireBytes {
fn new(owner: impl StableByteOwner) -> Self {
Self(StableBytes::new(owner))
}
fn as_slice(&self) -> &[u8] {
self.0.as_slice()
}
}
impl std::fmt::Debug for ExternalWireBytes {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_tuple("External")
.field(&self.as_slice())
.finish()
}
}
impl PartialEq for ExternalWireBytes {
fn eq(&self, other: &Self) -> bool {
self.as_slice() == other.as_slice()
}
}
impl Eq for ExternalWireBytes {}
#[derive(Debug, Eq, PartialEq)]
pub enum WireSegment {
Inline(SmallVec<[u8; 32]>),
Owned(OwnedRange),
External(ExternalWireBytes),
}
const _: () = assert!(std::mem::size_of::<WireSegment>() <= 48);
impl WireSegment {
pub fn inline(bytes: &[u8]) -> Self {
Self::Inline(SmallVec::from_slice(bytes))
}
pub fn owned(bytes: impl Into<OwnedRange>) -> Self {
Self::Owned(bytes.into())
}
pub fn external(owner: impl StableByteOwner) -> Self {
Self::External(ExternalWireBytes::new(owner))
}
pub fn as_slice(&self) -> &[u8] {
match self {
Self::Inline(bytes) => bytes,
Self::Owned(bytes) => bytes.as_slice(),
Self::External(bytes) => bytes.as_slice(),
}
}
pub fn len(&self) -> usize {
self.as_slice().len()
}
pub fn is_empty(&self) -> bool {
self.as_slice().is_empty()
}
}
impl From<OwnedRange> for WireSegment {
fn from(value: OwnedRange) -> Self {
Self::owned(value)
}
}
impl From<InlineBytes> for WireSegment {
fn from(value: InlineBytes) -> Self {
Self::Inline(value.0)
}
}
impl From<StableBytes> for WireSegment {
fn from(value: StableBytes) -> Self {
Self::External(ExternalWireBytes(value))
}
}
impl From<Vec<u8>> for WireSegment {
fn from(value: Vec<u8>) -> Self {
Self::owned(value)
}
}
#[derive(Debug, Eq, PartialEq)]
pub struct SegmentFrame<A>
where
A: Array<Item = WireSegment>,
{
segments: SmallVec<A>,
encoded_len: usize,
}
impl<A> SegmentFrame<A>
where
A: Array<Item = WireSegment>,
{
pub fn new<I, T>(segments: I) -> Result<Self>
where
I: IntoIterator<Item = T>,
T: Into<WireSegment>,
{
let segments: SmallVec<A> = segments.into_iter().map(Into::into).collect();
Self::from_segments(segments)
}
pub(crate) fn from_segments(segments: SmallVec<A>) -> Result<Self> {
let encoded_len = segments.iter().try_fold(0usize, |total, segment| {
total
.checked_add(segment.len())
.ok_or(ProtocolError::FrameLengthOverflow)
})?;
Ok(Self {
segments,
encoded_len,
})
}
pub fn segments(&self) -> &[WireSegment] {
&self.segments
}
pub const fn len(&self) -> usize {
self.encoded_len
}
pub const fn is_empty(&self) -> bool {
self.encoded_len == 0
}
pub fn into_segments(self) -> SmallVec<A> {
self.segments
}
}
pub use WireSegment as ResponseSegment;