Skip to main content

qdrant_client/builders/
rename_alias_builder.rs

1use crate::qdrant::*;
2
3#[derive(Clone)]
4pub struct RenameAliasBuilder {
5    /// Name of the alias to rename
6    pub(crate) old_alias_name: Option<String>,
7    /// Name of the alias
8    pub(crate) new_alias_name: Option<String>,
9}
10
11impl RenameAliasBuilder {
12    /// Name of the alias to rename
13    pub fn old_alias_name(self, value: String) -> Self {
14        let mut new = self;
15        new.old_alias_name = Option::Some(value);
16        new
17    }
18    /// Name of the alias
19    pub fn new_alias_name(self, value: String) -> Self {
20        let mut new = self;
21        new.new_alias_name = Option::Some(value);
22        new
23    }
24
25    fn build_inner(self) -> Result<RenameAlias, RenameAliasBuilderError> {
26        Ok(RenameAlias {
27            old_alias_name: match self.old_alias_name {
28                Some(value) => value,
29                None => {
30                    return Result::Err(core::convert::Into::into(
31                        ::derive_builder::UninitializedFieldError::from("old_alias_name"),
32                    ));
33                }
34            },
35            new_alias_name: match self.new_alias_name {
36                Some(value) => value,
37                None => {
38                    return Result::Err(core::convert::Into::into(
39                        ::derive_builder::UninitializedFieldError::from("new_alias_name"),
40                    ));
41                }
42            },
43        })
44    }
45    /// Create an empty builder, with all fields set to `None` or `PhantomData`.
46    fn create_empty() -> Self {
47        Self {
48            old_alias_name: core::default::Default::default(),
49            new_alias_name: core::default::Default::default(),
50        }
51    }
52}
53
54impl From<RenameAliasBuilder> for RenameAlias {
55    fn from(value: RenameAliasBuilder) -> Self {
56        value.build_inner().unwrap_or_else(|_| {
57            panic!(
58                "Failed to convert {0} to {1}",
59                "RenameAliasBuilder", "RenameAlias"
60            )
61        })
62    }
63}
64
65impl RenameAliasBuilder {
66    /// Builds the desired type. Can often be omitted.
67    pub fn build(self) -> RenameAlias {
68        self.build_inner().unwrap_or_else(|_| {
69            panic!(
70                "Failed to build {0} into {1}",
71                "RenameAliasBuilder", "RenameAlias"
72            )
73        })
74    }
75}
76
77impl RenameAliasBuilder {
78    pub(crate) fn empty() -> Self {
79        Self::create_empty()
80    }
81}
82
83/// Error type for RenameAliasBuilder
84#[non_exhaustive]
85#[derive(Debug)]
86pub enum RenameAliasBuilderError {
87    /// Uninitialized field
88    UninitializedField(&'static str),
89    /// Custom validation error
90    ValidationError(String),
91}
92
93// Implementing the Display trait for better error messages
94impl std::fmt::Display for RenameAliasBuilderError {
95    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
96        match self {
97            Self::UninitializedField(field) => {
98                write!(f, "`{field}` must be initialized")
99            }
100            Self::ValidationError(error) => write!(f, "{error}"),
101        }
102    }
103}
104
105// Implementing the Error trait
106impl std::error::Error for RenameAliasBuilderError {}
107
108// Implementing From trait for conversion from UninitializedFieldError
109impl From<derive_builder::UninitializedFieldError> for RenameAliasBuilderError {
110    fn from(error: derive_builder::UninitializedFieldError) -> Self {
111        Self::UninitializedField(error.field_name())
112    }
113}
114
115// Implementing From trait for conversion from String
116impl From<String> for RenameAliasBuilderError {
117    fn from(error: String) -> Self {
118        Self::ValidationError(error)
119    }
120}