Add some forwarding impls Hash, Ord, PartialOrd

Author: udoprog

fixed-map-derive/src/any_variants.rs

@@ -32,6 +32,7 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
     let mut field_inits = Vec::new();
     let mut field_clones = Vec::new();
     let mut field_partial_eqs = Vec::new();
+    let mut field_partial_not_eqs = Vec::new();
     let mut contains_key = Vec::new();
     let mut get = Vec::new();
     let mut get_mut = Vec::new();
@@ -48,12 +49,19 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
 
         field_inits.push(quote!(#name: #default::default()));
         field_clones.push(quote!(#name: #clone::clone(&self.#name)));
+
         field_partial_eqs.push(quote! {
-            if self.#name != other.#name {
+            if #partial_eq::ne(&self.#name, &other.#name) {
                 return false;
             }
         });
 
+        field_partial_not_eqs.push(quote! {
+            if #partial_eq::ne(&self.#name, &other.#name) {
+                return true;
+            }
+        });
+
         let kind = match &variant.fields {
             Fields::Unit => {
                 len.push(quote!(usize::from(#option::is_some(&self.#name))));
@@ -176,6 +184,12 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
                     #(#field_partial_eqs;)*
                     true
                 }
+
+                #[inline]
+                fn ne(&self, other: &Storage<V>) -> bool {
+                    #(#field_partial_not_eqs;)*
+                    false
+                }
             }
 
             #[automatically_derived]

fixed-map-derive/src/context.rs

@@ -13,13 +13,18 @@ pub(crate) struct Toks {
     pub(crate) default: TokenStream,
     pub(crate) double_ended_iterator_t: TokenStream,
     pub(crate) eq: TokenStream,
+    pub(crate) hash: TokenStream,
+    pub(crate) hasher: TokenStream,
     pub(crate) into_iter: TokenStream,
     pub(crate) iterator_t: TokenStream,
     pub(crate) iterator_flatten: TokenStream,
     pub(crate) key_trait: TokenStream,
     pub(crate) mem: TokenStream,
     pub(crate) option: TokenStream,
     pub(crate) partial_eq: TokenStream,
+    pub(crate) partial_ord: TokenStream,
+    pub(crate) ordering: TokenStream,
+    pub(crate) ord: TokenStream,
     pub(crate) slice_iter_mut: TokenStream,
     pub(crate) slice_iter: TokenStream,
     pub(crate) storage_trait: TokenStream,
@@ -43,13 +48,18 @@ impl Toks {
             default: quote!(::core::default::Default),
             double_ended_iterator_t: quote!(::core::iter::DoubleEndedIterator),
             eq: quote!(::core::cmp::Eq),
+            hash: quote!(::core::hash::Hash),
+            hasher: quote!(::core::hash::Hasher),
             into_iter: quote!(::core::iter::IntoIterator::into_iter),
             iterator_t: quote!(::core::iter::Iterator),
             iterator_flatten: quote!(::core::iter::Flatten),
             key_trait: quote!(#krate::key::Key),
             mem: quote!(::core::mem),
             option: quote!(::core::option::Option),
             partial_eq: quote!(::core::cmp::PartialEq),
+            partial_ord: quote!(::core::cmp::PartialOrd),
+            ordering: quote!(::core::cmp::Ordering),
+            ord: quote!(::core::cmp::Ord),
             slice_iter_mut: quote!(::core::slice::IterMut),
             slice_iter: quote!(::core::slice::Iter),
             storage_trait: quote!(#krate::storage::Storage),

fixed-map-derive/src/unit_variants.rs

@@ -14,13 +14,18 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
     let copy = &cx.toks.copy;
     let default = &cx.toks.default;
     let eq = &cx.toks.eq;
+    let hash = &cx.toks.hash;
+    let hasher = &cx.toks.hasher;
     let into_iter = &cx.toks.into_iter;
     let iterator = &cx.toks.iterator_t;
     let iterator_flatten = &cx.toks.iterator_flatten;
     let key_trait = &cx.toks.key_trait;
     let mem = &cx.toks.mem;
     let option = &cx.toks.option;
     let partial_eq = &cx.toks.partial_eq;
+    let partial_ord = &cx.toks.partial_ord;
+    let ordering = &cx.toks.ordering;
+    let ord = &cx.toks.ord;
     let slice_iter = &cx.toks.slice_iter;
     let slice_iter_mut = &cx.toks.slice_iter_mut;
     let array_into_iter = &cx.toks.array_into_iter;
@@ -191,16 +196,86 @@ pub(crate) fn implement(cx: &Ctxt<'_>, en: &DataEnum) -> Result<TokenStream, ()>
             }
 
             #[automatically_derived]
-            impl<V> #partial_eq for Storage<V> where V: #partial_eq{
+            impl<V> #partial_eq for Storage<V> where V: #partial_eq {
                 #[inline]
                 fn eq(&self, other: &Storage<V>) -> bool {
-                    self.data == other.data
+                    #partial_eq::eq(&self.data, &other.data)
+                }
+
+                #[inline]
+                fn ne(&self, other: &Storage<V>) -> bool {
+                    #partial_eq::ne(&self.data, &other.data)
                 }
             }
 
             #[automatically_derived]
             impl<V> #eq for Storage<V> where V: #eq {}
 
+            #[automatically_derived]
+            impl<V> #hash for Storage<V> where V: #hash {
+                #[inline]
+                fn hash<H>(&self, state: &mut H)
+                where
+                    H: #hasher,
+                {
+                    #hash::hash(&self.data, state);
+                }
+            }
+
+            #[automatically_derived]
+            impl<V> #partial_ord for Storage<V> where V: #partial_ord {
+                #[inline]
+                fn partial_cmp(&self, other: &Self) -> Option<#ordering> {
+                    #partial_ord::partial_cmp(&self.data, &other.data)
+                }
+
+                #[inline]
+                fn lt(&self, other: &Self) -> bool {
+                    #partial_ord::lt(&self.data, &other.data)
+                }
+
+                #[inline]
+                fn le(&self, other: &Self) -> bool {
+                    #partial_ord::le(&self.data, &other.data)
+                }
+
+                #[inline]
+                fn gt(&self, other: &Self) -> bool {
+                    #partial_ord::gt(&self.data, &other.data)
+                }
+
+                #[inline]
+                fn ge(&self, other: &Self) -> bool {
+                    #partial_ord::ge(&self.data, &other.data)
+                }
+            }
+
+            #[automatically_derived]
+            impl<V> #ord for Storage<V> where V: #ord {
+                #[inline]
+                fn cmp(&self, other: &Self) -> #ordering {
+                    #ord::cmp(self, other)
+                }
+
+                #[inline]
+                fn max(self, other: Self) -> Self {
+                    Self { data: #ord::max(self.data, other.data) }
+                }
+
+                #[inline]
+                fn min(self, other: Self) -> Self {
+                    Self { data: #ord::min(self.data, other.data) }
+                }
+
+                #[inline]
+                fn clamp(self, min: Self, max: Self) -> Self
+                where
+                    Self: #partial_ord<Self>
+                {
+                    Self { data: #ord::clamp(self.data, min.data, max.data) }
+                }
+            }
+
             #[automatically_derived]
             impl<V> #default for Storage<V> {
                 #[inline]