qdrant_client/builders/
move_shard_builder.rs

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