Skip to main content

qdrant_client/builders/
rename_alias_builder.rs

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