use kafka_client_core::{
AlterClientQuotaEntity as CoreEntity, AlterClientQuotaEntityComponent as CoreComponent,
AlterClientQuotaEntry as CoreEntry, AlterClientQuotaOperation as CoreOperation,
AlterClientQuotasPlan as CorePlan, AlterClientQuotasPlanError as CorePlanError,
};
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterClientQuotaEntityComponent {
entity_type: String,
entity_name: Option<String>,
}
impl AlterClientQuotaEntityComponent {
pub const fn new(entity_type: String, entity_name: Option<String>) -> Self {
Self {
entity_type,
entity_name,
}
}
pub fn entity_type(&self) -> &str {
&self.entity_type
}
pub fn entity_name(&self) -> Option<&str> {
self.entity_name.as_deref()
}
pub fn into_parts(self) -> (String, Option<String>) {
(self.entity_type, self.entity_name)
}
fn into_core(self) -> CoreComponent {
let (entity_type, entity_name) = self.into_parts();
CoreComponent::new(
canonical_string(entity_type),
entity_name.map(canonical_string),
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AlterClientQuotaEntity {
components: Vec<AlterClientQuotaEntityComponent>,
}
impl AlterClientQuotaEntity {
pub const fn new(components: Vec<AlterClientQuotaEntityComponent>) -> Self {
Self { components }
}
pub fn components(&self) -> &[AlterClientQuotaEntityComponent] {
&self.components
}
pub fn into_components(self) -> Vec<AlterClientQuotaEntityComponent> {
self.components
}
fn canonicalize(mut self) -> Self {
self.components.shrink_to_fit();
self
}
fn into_core(self) -> CoreEntity {
CoreEntity::new(
self.into_components()
.into_iter()
.map(AlterClientQuotaEntityComponent::into_core)
.collect(),
)
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AlterClientQuotaOperation {
Set {
key: String,
value: f64,
},
Remove {
key: String,
},
}
impl AlterClientQuotaOperation {
pub fn set(key: String, value: f64) -> Self {
Self::Set { key, value }
}
pub fn remove(key: String) -> Self {
Self::Remove { key }
}
pub fn key(&self) -> &str {
match self {
Self::Set { key, .. } | Self::Remove { key } => key,
}
}
fn into_core(self) -> CoreOperation {
match self {
Self::Set { key, value } => CoreOperation::set(canonical_string(key), value),
Self::Remove { key } => CoreOperation::remove(canonical_string(key)),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct AlterClientQuotaEntry {
entity: AlterClientQuotaEntity,
operations: Vec<AlterClientQuotaOperation>,
}
impl AlterClientQuotaEntry {
pub const fn new(
entity: AlterClientQuotaEntity,
operations: Vec<AlterClientQuotaOperation>,
) -> Self {
Self { entity, operations }
}
pub const fn entity(&self) -> &AlterClientQuotaEntity {
&self.entity
}
pub fn operations(&self) -> &[AlterClientQuotaOperation] {
&self.operations
}
pub fn into_parts(self) -> (AlterClientQuotaEntity, Vec<AlterClientQuotaOperation>) {
(self.entity, self.operations)
}
fn canonicalize(mut self) -> Self {
self.entity = self.entity.canonicalize();
self.operations.shrink_to_fit();
self
}
fn into_core(self) -> CoreEntry {
let (entity, operations) = self.into_parts();
CoreEntry::new(
entity.into_core(),
operations
.into_iter()
.map(AlterClientQuotaOperation::into_core)
.collect(),
)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct AlterClientQuotasRequest {
entries: Vec<AlterClientQuotaEntry>,
validate_only: bool,
}
impl AlterClientQuotasRequest {
pub const fn new(entries: Vec<AlterClientQuotaEntry>, validate_only: bool) -> Self {
Self {
entries,
validate_only,
}
}
pub fn entries(&self) -> &[AlterClientQuotaEntry] {
&self.entries
}
pub const fn validate_only(&self) -> bool {
self.validate_only
}
pub fn into_parts(self) -> (Vec<AlterClientQuotaEntry>, bool) {
(self.entries, self.validate_only)
}
pub(crate) fn canonicalize(mut self) -> Self {
self.entries = self
.entries
.into_iter()
.map(AlterClientQuotaEntry::canonicalize)
.collect();
self.entries.shrink_to_fit();
self
}
pub(crate) fn into_plan(self) -> Result<CorePlan, CorePlanError> {
let (entries, validate_only) = self.into_parts();
CorePlan::new(
entries
.into_iter()
.map(AlterClientQuotaEntry::into_core)
.collect(),
validate_only,
)
}
}
fn canonical_string(value: String) -> String {
value.into_boxed_str().into_string()
}