Skip to main content

qdrant_client/builders/
delete_vector_name_request_builder.rs

1use crate::qdrant::*;
2
3#[must_use]
4#[derive(Clone)]
5pub struct DeleteVectorNameRequestBuilder {
6    /// Name of the collection
7    pub(crate) collection_name: Option<String>,
8    /// Wait until the changes have been applied?
9    pub(crate) wait: Option<Option<bool>>,
10    /// Name of the vector to delete
11    pub(crate) vector_name: Option<String>,
12    /// If set, overrides global timeout setting for this request. Unit is seconds.
13    pub(crate) timeout: Option<Option<u64>>,
14    /// Write ordering guarantees
15    pub(crate) ordering: Option<Option<WriteOrdering>>,
16}
17
18impl DeleteVectorNameRequestBuilder {
19    /// Name of the collection
20    pub fn collection_name(self, value: impl Into<String>) -> Self {
21        let mut new = self;
22        new.collection_name = Option::Some(value.into());
23        new
24    }
25
26    /// Wait until the changes have been applied?
27    pub fn wait(self, value: bool) -> Self {
28        let mut new = self;
29        new.wait = Option::Some(Option::Some(value));
30        new
31    }
32
33    /// Name of the vector to delete
34    pub fn vector_name(self, value: impl Into<String>) -> Self {
35        let mut new = self;
36        new.vector_name = Option::Some(value.into());
37        new
38    }
39
40    /// If set, overrides global timeout setting for this request. Unit is seconds.
41    pub fn timeout(self, value: u64) -> Self {
42        let mut new = self;
43        new.timeout = Option::Some(Option::Some(value));
44        new
45    }
46
47    /// Write ordering guarantees
48    pub fn ordering<VALUE: core::convert::Into<WriteOrdering>>(self, value: VALUE) -> Self {
49        let mut new = self;
50        new.ordering = Option::Some(Option::Some(value.into()));
51        new
52    }
53
54    fn build_inner(self) -> Result<DeleteVectorNameRequest, DeleteVectorNameRequestBuilderError> {
55        Ok(DeleteVectorNameRequest {
56            collection_name: match self.collection_name {
57                Some(value) => value,
58                None => {
59                    return Result::Err(core::convert::Into::into(
60                        ::derive_builder::UninitializedFieldError::from("collection_name"),
61                    ));
62                }
63            },
64            wait: self.wait.unwrap_or_default(),
65            vector_name: match self.vector_name {
66                Some(value) => value,
67                None => {
68                    return Result::Err(core::convert::Into::into(
69                        ::derive_builder::UninitializedFieldError::from("vector_name"),
70                    ));
71                }
72            },
73            timeout: self.timeout.unwrap_or_default(),
74            ordering: self.ordering.unwrap_or_default(),
75        })
76    }
77    /// Create an empty builder, with all fields set to `None` or `PhantomData`.
78    fn create_empty() -> Self {
79        Self {
80            collection_name: core::default::Default::default(),
81            wait: core::default::Default::default(),
82            vector_name: core::default::Default::default(),
83            timeout: core::default::Default::default(),
84            ordering: core::default::Default::default(),
85        }
86    }
87}
88
89impl From<DeleteVectorNameRequestBuilder> for DeleteVectorNameRequest {
90    fn from(value: DeleteVectorNameRequestBuilder) -> Self {
91        value.build_inner().unwrap_or_else(|_| {
92            panic!(
93                "Failed to convert {0} to {1}",
94                "DeleteVectorNameRequestBuilder", "DeleteVectorNameRequest"
95            )
96        })
97    }
98}
99
100impl DeleteVectorNameRequestBuilder {
101    /// Builds the desired type. Can often be omitted.
102    pub fn build(self) -> DeleteVectorNameRequest {
103        self.build_inner().unwrap_or_else(|_| {
104            panic!(
105                "Failed to build {0} into {1}",
106                "DeleteVectorNameRequestBuilder", "DeleteVectorNameRequest"
107            )
108        })
109    }
110}
111
112impl DeleteVectorNameRequestBuilder {
113    pub(crate) fn empty() -> Self {
114        Self::create_empty()
115    }
116}
117
118/// Error type for DeleteVectorNameRequestBuilder
119#[non_exhaustive]
120#[derive(Debug)]
121pub enum DeleteVectorNameRequestBuilderError {
122    /// Uninitialized field
123    UninitializedField(&'static str),
124    /// Custom validation error
125    ValidationError(String),
126}
127
128// Implementing the Display trait for better error messages
129impl std::fmt::Display for DeleteVectorNameRequestBuilderError {
130    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
131        match self {
132            Self::UninitializedField(field) => {
133                write!(f, "`{field}` must be initialized")
134            }
135            Self::ValidationError(error) => write!(f, "{error}"),
136        }
137    }
138}
139
140// Implementing the Error trait
141impl std::error::Error for DeleteVectorNameRequestBuilderError {}
142
143// Implementing From trait for conversion from UninitializedFieldError
144impl From<derive_builder::UninitializedFieldError> for DeleteVectorNameRequestBuilderError {
145    fn from(error: derive_builder::UninitializedFieldError) -> Self {
146        Self::UninitializedField(error.field_name())
147    }
148}
149
150// Implementing From trait for conversion from String
151impl From<String> for DeleteVectorNameRequestBuilderError {
152    fn from(error: String) -> Self {
153        Self::ValidationError(error)
154    }
155}