qdrant_client/builders/
product_quantization_builder.rs

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

qdrant_client/builders/
product_quantization_builder.rs
