use super::error::{error, CborError, ErrorReason};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum LengthPolicy {
DefiniteOnly,
AllowIndefinite,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum Serialization {
Received,
Preferred,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum FloatPolicy {
All,
FiniteOnly,
Reject,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum MapOrdering {
Received,
LengthFirst,
Bytewise,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Profile {
pub(super) serialization: Serialization,
pub(super) lengths: LengthPolicy,
pub(super) floats: FloatPolicy,
pub(super) ordering: MapOrdering,
}
impl Profile {
pub fn new(
serialization: Serialization,
lengths: LengthPolicy,
floats: FloatPolicy,
ordering: MapOrdering,
) -> Result<Self, CborError> {
if serialization == Serialization::Preferred && lengths != LengthPolicy::DefiniteOnly {
return Err(error(ErrorReason::UnsupportedPolicy));
}
Ok(Self {
serialization,
lengths,
floats,
ordering,
})
}
#[must_use]
pub const fn received() -> Self {
Self {
serialization: Serialization::Received,
lengths: LengthPolicy::AllowIndefinite,
floats: FloatPolicy::All,
ordering: MapOrdering::Received,
}
}
#[must_use]
pub const fn preferred() -> Self {
Self {
serialization: Serialization::Preferred,
lengths: LengthPolicy::DefiniteOnly,
floats: FloatPolicy::All,
ordering: MapOrdering::Received,
}
}
#[must_use]
pub const fn with_floats(mut self, policy: FloatPolicy) -> Self {
self.floats = policy;
self
}
#[must_use]
pub const fn with_map_ordering(mut self, ordering: MapOrdering) -> Self {
self.ordering = ordering;
self
}
#[must_use]
pub const fn lengths(self) -> LengthPolicy {
self.lengths
}
#[must_use]
pub const fn serialization(self) -> Serialization {
self.serialization
}
#[must_use]
pub const fn floats(self) -> FloatPolicy {
self.floats
}
#[must_use]
pub const fn map_ordering(self) -> MapOrdering {
self.ordering
}
}