qdrant_client/builders/
create_shard_key_request_builder.rs

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