Grcov report - get.rs

1

use futures::{Future, FutureExt};

2

use serde::Deserialize;

3

4

use super::{BuilderState, Command, KeyOperation, KeyValue, Output};

5

use crate::{keyvalue::Value, Error};

6

7

/// Executes [`Command::Get`] when awaited. Also offers methods to customize the

8

/// options for the operation.

9

#[must_use = "futures do nothing unless you `.await` or poll them"]

10

pub struct Builder<'a, KeyValue> {

11

    state: BuilderState<'a, Options<'a, KeyValue>, Result<Option<Value>, Error>>,

12

13

14

struct Options<'a, KeyValue> {

15

    kv: &'a KeyValue,

16

    namespace: Option<String>,

17

    key: String,

18

    delete: bool,

19

20

21

impl<'a, K> Builder<'a, K>

22

where

23

    K: KeyValue,

24

25

157

    pub(crate) fn new(kv: &'a K, namespace: Option<String>, key: String) -> Self {

26

157

        Self {

27

157

            state: BuilderState::Pending(Some(Options {

28

157

                key,

29

157

kv,

30

157

                namespace,

31

157

                delete: false,

32

157

            })),

33

157

34

157

35

36

8

    fn options(&mut self) -> &mut Options<'a, K> {

37

8

        if let BuilderState::Pending(Some(options)) = &mut self.state {

38

8

            options

39

        } else {

40

            unreachable!("Attempted to use after retrieving the result")

41

42

8

43

44

    /// Delete the key after retrieving the value.

45

8

    pub fn and_delete(mut self) -> Self {

46

8

        self.options().delete = true;

47

8

        self

48

8

49

50

    /// Deserializes the [`Value`] before returning. If the value is a

51

    /// [`Numeric`](crate::keyvalue::Numeric), an error will be returned.

52

26

    pub async fn into<V: for<'de> Deserialize<'de>>(self) -> Result<Option<V>, Error> {

53

26

        self.await?.map(|value| value.deserialize()).transpose()

54

26

55

56

    /// Converts the [`Value`] to an `u64` before returning. If the value is not

57

    /// a [`Numeric`](crate::keyvalue::Numeric), an error will be returned. If the conversion to `u64`

58

    /// cannot be done without losing data, an error will be returned.

59

    #[allow(clippy::cast_sign_loss)]

60

21

    pub async fn into_u64(self) -> Result<Option<u64>, Error> {

61

21

        match self.await? {

62

20

            Some(value) => value.as_u64().map_or_else(

63

20

                || {

64

12

                    Err(Error::Database(String::from(

65

12

                        "value not an u64 or would lose precision when converted to an u64",

66

12

)))

67

20

},

68

20

                |value| Ok(Some(value)),

69

20

),

70

1

            None => Ok(None),

71

72

21

73

74

    /// Converts the [`Value`] to an `i64` before returning. If the value is not

75

    /// a [`Numeric`](crate::keyvalue::Numeric), an error will be returned. If the conversion to `i64`

76

    /// cannot be done without losing data, an error will be returned.

77

    #[allow(clippy::cast_possible_wrap)]

78

16

    pub async fn into_i64(self) -> Result<Option<i64>, Error> {

79

16

        match self.await? {

80

16

            Some(value) => value.as_i64().map_or_else(

81

16

                || {

82

12

                    Err(Error::Database(String::from(

83

12

                        "value not an i64 or would lose precision when converted to an i64",

84

12

)))

85

16

},

86

16

                |value| Ok(Some(value)),

87

16

),

88

            None => Ok(None),

89

90

16

91

92

    /// Converts the [`Value`] to an `f64` before returning. If the value is not

93

    /// a [`Numeric`](crate::keyvalue::Numeric), an error will be returned. If the conversion to `f64`

94

    /// cannot be done without losing data, an error will be returned.

95

    #[allow(clippy::cast_precision_loss)]

96

24

    pub async fn into_f64(self) -> Result<Option<f64>, Error> {

97

24

        match self.await? {

98

24

            Some(value) => value.as_f64().map_or_else(

99

24

                || {

100

8

                    Err(Error::Database(String::from(

101

8

                        "value not an f64 or would lose precision when converted to an f64",

102

8

)))

103

24

},

104

24

                |value| Ok(Some(value)),

105

24

),

106

            None => Ok(None),

107

108

24

109

110

    /// Converts the [`Value`] to an `u64` before returning. If the value is not

111

    /// a [`Numeric`](crate::keyvalue::Numeric), an error will be returned. If `saturating` is true, no

112

    /// overflows will be allowed during conversion.

113

    #[allow(clippy::cast_sign_loss)]

114

16

    pub async fn into_u64_lossy(self, saturating: bool) -> Result<Option<u64>, Error> {

115

16

        match self.await? {

116

16

            Some(value) => value.as_u64_lossy(saturating).map_or_else(

117

16

                || Err(Error::Database(String::from("value not numeric"))),

118

16

                |value| Ok(Some(value)),

119

16

),

120

            None => Ok(None),

121

122

16

123

124

    /// Converts the [`Value`] to an `i64` before returning. If the value is not

125

    /// a [`Numeric`](crate::keyvalue::Numeric), an error will be returned. If `saturating` is true, no

126

    /// overflows will be allowed during conversion.

127

    #[allow(clippy::cast_possible_wrap)]

128

16

    pub async fn into_i64_lossy(self, saturating: bool) -> Result<Option<i64>, Error> {

129

16

        match self.await? {

130

16

            Some(value) => value.as_i64_lossy(saturating).map_or_else(

131

16

                || Err(Error::Database(String::from("value not numeric"))),

132

16

                |value| Ok(Some(value)),

133

16

),

134

            None => Ok(None),

135

136

16

137

138

    /// Converts the [`Value`] to an `f64` before returning. If the value is not

139

    /// a [`Numeric`](crate::keyvalue::Numeric), an error will be returned.

140

    #[allow(clippy::cast_precision_loss)]

141

8

    pub async fn into_f64_lossy(self) -> Result<Option<f64>, Error> {

142

8

        match self.await? {

143

8

            Some(value) => value.as_f64_lossy().map_or_else(

144

8

                || Err(Error::Database(String::from("value not numeric"))),

145

8

                |value| Ok(Some(value)),

146

8

),

147

            None => Ok(None),

148

149

8

150

151

152

impl<'a, K> Future for Builder<'a, K>

153

where

154

    K: KeyValue,

155

156

    type Output = Result<Option<Value>, Error>;

157

158

394

    fn poll(

159

394

        mut self: std::pin::Pin<&mut Self>,

160

394

        cx: &mut std::task::Context<'_>,

161

394

    ) -> std::task::Poll<Self::Output> {

162

394

        match &mut self.state {

163

237

            BuilderState::Executing(future) => future.as_mut().poll(cx),

164

157

            BuilderState::Pending(builder) => {

165

157

                let Options {

166

157

kv,

167

157

                    namespace,

168

157

                    key,

169

157

                    delete,

170

157

                } = builder.take().expect("expected builder to have options");

171

157

                let future = async move {

172

157

                    let result = kv

173

157

                        .execute_key_operation(KeyOperation {

174

157

                            namespace,

175

157

                            key,

176

157

                            command: Command::Get { delete },

177

157

})

178

80

                        .await?;

179

157

                    if let Output::Value(value) = result {

180

157

                        Ok(value)

181

                    } else {

182

                        unreachable!("Unexpected result from get")

183

184

157

185

157

                .boxed();

186

157

187

157

                self.state = BuilderState::Executing(future);

188

157

                self.poll(cx)

189

190

191

394

192