@@ -15,6 +15,10 @@ use bincode::{enc::write::Writer, error::DecodeError, BorrowDecode, Decode, Enco
1515use grovedb_costs:: { CostContext , CostsExt , OperationCost } ;
1616#[ cfg( feature = "full" ) ]
1717use grovedb_storage:: RawIterator ;
18+ #[ cfg( feature = "serde" ) ]
19+ use serde:: de:: VariantAccess ;
20+ #[ cfg( feature = "serde" ) ]
21+ use serde:: { Deserialize , Deserializer , Serialize , Serializer } ;
1822
1923#[ cfg( any( feature = "full" , feature = "verify" ) ) ]
2024use crate :: error:: Error ;
@@ -36,6 +40,149 @@ pub enum QueryItem {
3640 RangeAfterToInclusive ( RangeInclusive < Vec < u8 > > ) ,
3741}
3842
43+ #[ cfg( feature = "serde" ) ]
44+ impl Serialize for QueryItem {
45+ fn serialize < S > ( & self , serializer : S ) -> Result < S :: Ok , S :: Error >
46+ where
47+ S : Serializer ,
48+ {
49+ match self {
50+ QueryItem :: Key ( key) => serializer. serialize_newtype_variant ( "QueryItem" , 0 , "Key" , key) ,
51+ QueryItem :: Range ( range) => {
52+ serializer. serialize_newtype_variant ( "QueryItem" , 1 , "Range" , & range)
53+ }
54+ QueryItem :: RangeInclusive ( range) => {
55+ serializer. serialize_newtype_variant ( "QueryItem" , 2 , "RangeInclusive" , range)
56+ }
57+ QueryItem :: RangeFull ( _) => {
58+ serializer. serialize_unit_variant ( "QueryItem" , 3 , "RangeFull" )
59+ }
60+ QueryItem :: RangeFrom ( range_from) => {
61+ serializer. serialize_newtype_variant ( "QueryItem" , 4 , "RangeFrom" , range_from)
62+ }
63+ QueryItem :: RangeTo ( range_to) => {
64+ serializer. serialize_newtype_variant ( "QueryItem" , 5 , "RangeTo" , range_to)
65+ }
66+ QueryItem :: RangeToInclusive ( range_to_inclusive) => serializer
67+ . serialize_newtype_variant (
68+ "QueryItem" ,
69+ 6 ,
70+ "RangeToInclusive" ,
71+ & range_to_inclusive. end ,
72+ ) ,
73+ QueryItem :: RangeAfter ( range_after) => {
74+ serializer. serialize_newtype_variant ( "QueryItem" , 7 , "RangeAfter" , range_after)
75+ }
76+ QueryItem :: RangeAfterTo ( range_after_to) => {
77+ serializer. serialize_newtype_variant ( "QueryItem" , 8 , "RangeAfterTo" , range_after_to)
78+ }
79+ QueryItem :: RangeAfterToInclusive ( range_after_to_inclusive) => serializer
80+ . serialize_newtype_variant (
81+ "QueryItem" ,
82+ 9 ,
83+ "RangeAfterToInclusive" ,
84+ range_after_to_inclusive,
85+ ) ,
86+ }
87+ }
88+ }
89+
90+ #[ cfg( feature = "serde" ) ]
91+ impl < ' de > Deserialize < ' de > for QueryItem {
92+ fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error >
93+ where
94+ D : Deserializer < ' de > ,
95+ {
96+ #[ derive( Deserialize ) ]
97+ #[ serde( field_identifier, rename_all = "snake_case" ) ]
98+ enum Field {
99+ Key ,
100+ Range ,
101+ RangeInclusive ,
102+ RangeFull ,
103+ RangeFrom ,
104+ RangeTo ,
105+ RangeToInclusive ,
106+ RangeAfter ,
107+ RangeAfterTo ,
108+ RangeAfterToInclusive ,
109+ }
110+
111+ struct QueryItemVisitor ;
112+
113+ impl < ' de > serde:: de:: Visitor < ' de > for QueryItemVisitor {
114+ type Value = QueryItem ;
115+
116+ fn expecting ( & self , formatter : & mut std:: fmt:: Formatter ) -> std:: fmt:: Result {
117+ formatter. write_str ( "enum QueryItem" )
118+ }
119+
120+ fn visit_enum < A > ( self , data : A ) -> Result < Self :: Value , A :: Error >
121+ where
122+ A : serde:: de:: EnumAccess < ' de > ,
123+ {
124+ let ( variant, variant_access) = data. variant ( ) ?;
125+
126+ match variant {
127+ Field :: Key => {
128+ let key = variant_access. newtype_variant ( ) ?;
129+ Ok ( QueryItem :: Key ( key) )
130+ }
131+ Field :: Range => {
132+ let range = variant_access. newtype_variant ( ) ?;
133+ Ok ( QueryItem :: Range ( range) )
134+ }
135+ Field :: RangeInclusive => {
136+ let range_inclusive = variant_access. newtype_variant ( ) ?;
137+ Ok ( QueryItem :: RangeInclusive ( range_inclusive) )
138+ }
139+ Field :: RangeFull => Ok ( QueryItem :: RangeFull ( RangeFull ) ) ,
140+ Field :: RangeFrom => {
141+ let range_from = variant_access. newtype_variant ( ) ?;
142+ Ok ( QueryItem :: RangeFrom ( range_from) )
143+ }
144+ Field :: RangeTo => {
145+ let range_to = variant_access. newtype_variant ( ) ?;
146+ Ok ( QueryItem :: RangeTo ( range_to) )
147+ }
148+ Field :: RangeToInclusive => {
149+ // Deserialize the `Vec<u8>` for the `end` of the range
150+ let end = variant_access. newtype_variant ( ) ?;
151+ Ok ( QueryItem :: RangeToInclusive ( ..=end) )
152+ }
153+ Field :: RangeAfter => {
154+ let range_after = variant_access. newtype_variant ( ) ?;
155+ Ok ( QueryItem :: RangeAfter ( range_after) )
156+ }
157+ Field :: RangeAfterTo => {
158+ let range_after_to = variant_access. newtype_variant ( ) ?;
159+ Ok ( QueryItem :: RangeAfterTo ( range_after_to) )
160+ }
161+ Field :: RangeAfterToInclusive => {
162+ let range_after_to_inclusive = variant_access. newtype_variant ( ) ?;
163+ Ok ( QueryItem :: RangeAfterToInclusive ( range_after_to_inclusive) )
164+ }
165+ }
166+ }
167+ }
168+
169+ const VARIANTS : & [ & str ] = & [
170+ "Key" ,
171+ "Range" ,
172+ "RangeInclusive" ,
173+ "RangeFull" ,
174+ "RangeFrom" ,
175+ "RangeTo" ,
176+ "RangeToInclusive" ,
177+ "RangeAfter" ,
178+ "RangeAfterTo" ,
179+ "RangeAfterToInclusive" ,
180+ ] ;
181+
182+ deserializer. deserialize_enum ( "QueryItem" , VARIANTS , QueryItemVisitor )
183+ }
184+ }
185+
39186#[ cfg( any( feature = "full" , feature = "verify" ) ) ]
40187impl Encode for QueryItem {
41188 fn encode < E : bincode:: enc:: Encoder > (
0 commit comments