use core::fmt;
use std::collections::TryReserveError;
mod translate;
pub(crate) use translate::{CreateAclsTranslationError, translate_terminal_into};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CreateAclsDeliveryStatus {
NotSent,
PossiblySent,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CreateAclBrokerError {
code: i16,
message: Option<String>,
message_truncated: bool,
}
impl CreateAclBrokerError {
pub const fn code(&self) -> i16 {
self.code
}
pub fn message(&self) -> Option<&str> {
self.message.as_deref()
}
pub const fn message_truncated(&self) -> bool {
self.message_truncated
}
pub fn into_parts(self) -> (i16, Option<String>, bool) {
(self.code, self.message, self.message_truncated)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CreateAclResult {
Created,
BrokerFailed(CreateAclBrokerError),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CreateAclOutcome {
binding: super::CreateAclBinding,
result: CreateAclResult,
}
impl CreateAclOutcome {
pub const fn binding(&self) -> &super::CreateAclBinding {
&self.binding
}
pub const fn result(&self) -> &CreateAclResult {
&self.result
}
pub fn into_parts(self) -> (super::CreateAclBinding, CreateAclResult) {
(self.binding, self.result)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CreateAclsBatch {
throttle_time_ms: u32,
outcomes: Vec<CreateAclOutcome>,
}
impl CreateAclsBatch {
pub(crate) fn try_prepare_outcomes(
required: usize,
) -> Result<Vec<CreateAclOutcome>, TryReserveError> {
let mut outcomes = Vec::new();
outcomes.try_reserve_exact(required)?;
Ok(outcomes)
}
pub const fn throttle_time_ms(&self) -> u32 {
self.throttle_time_ms
}
pub fn outcomes(&self) -> &[CreateAclOutcome] {
&self.outcomes
}
pub fn into_parts(self) -> (u32, Vec<CreateAclOutcome>) {
(self.throttle_time_ms, self.outcomes)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CreateAclsFailureKind {
DeadlineElapsed,
DriverRejected,
Transport,
ResponseTooLarge,
Compatibility,
InvalidResponse,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CreateAclsFailure {
kind: CreateAclsFailureKind,
delivery: CreateAclsDeliveryStatus,
}
impl CreateAclsFailure {
pub const fn kind(self) -> CreateAclsFailureKind {
self.kind
}
pub const fn delivery(self) -> CreateAclsDeliveryStatus {
self.delivery
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CreateAclsOutcome {
Created(CreateAclsBatch),
Failed(CreateAclsFailure),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CreateAclsObserverError {
AlreadyObserved,
Stale,
}
impl fmt::Display for CreateAclsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::AlreadyObserved => "Admin CreateAcls result was already observed",
Self::Stale => "Admin CreateAcls observer is stale",
})
}
}
impl std::error::Error for CreateAclsObserverError {}