Last few updates before 0.11.0

Author: slightlyoutofphase

Cargo.toml

@@ -18,6 +18,10 @@ status = "actively-developed"
 [badges.appveyor]
 repository = "slightlyoutofphase/staticvec"
 
+[package.metadata.docs.rs]
+features = ["std", "serde"]
+rustdoc-args = ["--cfg","docs_rs"]
+
 [profile.release]
 opt-level = 3
 debug = false
@@ -55,8 +59,6 @@ incremental = false
 
 [features]
 std = []
-serde_support = ["serde"]
-serde_json_support = ["serde_json"]
 default = ["std"]
 
 [[test]]
@@ -108,7 +110,7 @@ required-features = ["std"]
 [[example]]
 name = "serde_support_demo"
 path = "demo/serde_support_demo.rs"
-required-features = ["std", "serde_support", "serde_json_support"]
+required-features = ["std", "serde", "serde_json"]
 
 [dependencies]
 serde = { optional = true, version = "1.0", features = ["derive"] }

README.md

@@ -16,7 +16,7 @@ Fully `#![no_std]` compatible (with almost no loss of functionality) by setting
 `default-features = false` for the `staticvec` dependency in your `Cargo.toml`.
 
 Optional support for serialization and deserialization of the `StaticVec` struct
-via `serde` is available by activating the `serde_support` crate feature.
+via `serde` is available by activating the `serde` crate feature.
 
 `StaticVec` also implements both `Deref` and `DerefMut` to `[T]`, meaning that all existing slice
 methods are accessible through instances of it and that references to it can be used in contexts

src/heap/mod.rs

@@ -1,6 +1,6 @@
 use core::mem::swap;
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 use self::heap_helpers::StaticHeapHole;
@@ -98,7 +98,7 @@ mod heap_trait_impls;
 /// [pop]: #method.pop
 /// [peek]: #method.peek
 /// [peek\_mut]: #method.peek_mut
-#[cfg_attr(feature = "serde_support", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct StaticHeap<T, const N: usize> {
   pub(crate) data: StaticVec<T, N>,
 }

src/lib.rs

@@ -110,6 +110,12 @@ pub mod utils;
 
 /// A [`Vec`](alloc::vec::Vec)-like struct (mostly directly API-compatible where it can be)
 /// implemented with const generics around an array of fixed `N` capacity.
+///
+/// Please note that while rustdoc does currently correctly render inherent `const fn` method
+/// signatures, the same is not true of `const` trait implementation method signatures, so at this
+/// time it's recommended that you refer directly to the source code of this crate if unsure of
+/// whether a given trait has been implemented as `const` in conjunction with the `const_trait_impl`
+/// feature.
 pub struct StaticVec<T, const N: usize> {
   // We create this field in an uninitialized state, and write to it element-wise as needed via
   // pointer methods. At no time should the regular `assume_init` function *ever* be called through
@@ -1398,8 +1404,8 @@ impl<T, const N: usize> StaticVec<T, N> {
   /// );
   /// ```
   #[inline]
-  pub fn quicksorted_unstable(&self) -> Self
-  where T: Copy + PartialOrd {
+  pub const fn quicksorted_unstable(&self) -> Self
+  where T: Copy + ~const PartialOrd {
     let length = self.length;
     if length < 2 {
       // StaticVec uses specialization to have an optimized verson of `Clone` for copy types.
@@ -1433,8 +1439,8 @@ impl<T, const N: usize> StaticVec<T, N> {
   /// // values simply not being sorted quite as you'd hoped.
   /// ```
   #[inline]
-  pub fn quicksort_unstable(&mut self)
-  where T: Copy + PartialOrd {
+  pub const fn quicksort_unstable(&mut self)
+  where T: Copy + ~const PartialOrd {
     let length = self.length;
     if length < 2 {
       return;
@@ -2140,7 +2146,7 @@ impl<T, const N: usize> StaticVec<T, N> {
   /// assert_eq!(v2, [2, 3]);
   /// ```
   #[inline]
-  pub fn split_off(&mut self, at: usize) -> Self {
+  pub const fn split_off(&mut self, at: usize) -> Self {
     let old_length = self.length;
     assert!(
       at <= old_length,

src/macros.rs

@@ -86,12 +86,12 @@ macro_rules! staticvec {
 /// contexts.
 ///
 /// For example, this would give a compile-time error:
-/// ```
-/// // const S5: StaticString<1> = staticstring!("ABCDEFG", 1);
+/// ```compile_fail
+/// const S5: StaticString<1> = staticstring!("ABCDEFG", 1);
 /// ```
 /// As would the following:
-/// ```
-/// // let s6 = staticstring!("🤔🤔🤔🤔🤔🤔", 0);
+/// ```compile_fail
+/// let s6 = staticstring!("🤔🤔🤔🤔🤔🤔", 0);
 /// ```
 #[macro_export]
 #[rustfmt::skip]

src/string/string_errors.rs

@@ -69,6 +69,7 @@ impl Display for StringError {
 }
 
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl std::error::Error for StringError {}
 
 impl const From<DecodeUtf16Error> for StringError {

src/string/string_trait_impls.rs

@@ -15,7 +15,7 @@ use crate::StaticVec;
 #[cfg(feature = "std")]
 use alloc::string::String;
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
 use serde::{de::Deserializer, ser::Serializer, Deserialize, Serialize};
 
 impl<const N: usize> Add<&str> for StaticString<N> {
@@ -165,8 +165,8 @@ impl<const N: usize> From<StaticVec<u8, N>> for StaticString<N> {
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<const N: usize> From<String> for StaticString<N> {
   #[inline(always)]
   fn from(string: String) -> Self {
@@ -337,8 +337,8 @@ impl<const N: usize> PartialEq<&str> for StaticString<N> {
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<const N: usize> PartialEq<String> for StaticString<N> {
   #[inline(always)]
   fn eq(&self, other: &String) -> bool {
@@ -367,8 +367,8 @@ impl<const N: usize> PartialOrd<&str> for StaticString<N> {
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<const N: usize> PartialOrd<String> for StaticString<N> {
   #[inline(always)]
   fn partial_cmp(&self, other: &String) -> Option<Ordering> {
@@ -388,15 +388,17 @@ impl<const N: usize> Write for StaticString<N> {
   }
 }
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
+#[doc(cfg(feature = "serde"))]
 impl<'de, const N: usize> Deserialize<'de> for StaticString<N> {
   #[inline(always)]
   fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
     <&str>::deserialize(deserializer).map(Self::from_str)
   }
 }
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
+#[doc(cfg(feature = "serde"))]
 impl<const N: usize> Serialize for StaticString<N> {
   #[inline(always)]
   fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {

src/trait_impls.rs

@@ -31,10 +31,10 @@ use alloc::vec::Vec;
 #[cfg(feature = "std")]
 use std::io::{self, BufRead, IoSlice, IoSliceMut, Read, ReadBuf, Write};
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
 use core::marker::PhantomData;
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
 use serde::{
   de::{SeqAccess, Visitor},
   Deserialize, Deserializer, Serialize, Serializer,
@@ -456,8 +456,8 @@ impl<const N: usize> From<StaticString<N>> for StaticVec<u8, N> {
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<T, const N: usize> From<Vec<T>> for StaticVec<T, N> {
   /// Functionally equivalent to [`from_vec`](crate::StaticVec::from_vec).
   #[inline(always)]
@@ -693,9 +693,9 @@ impl<T, const N: usize> const IndexMut<RangeToInclusive<usize>> for StaticVec<T,
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[allow(clippy::from_over_into)]
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<T, const N: usize> Into<Vec<T>> for StaticVec<T, N> {
   /// Functionally equivalent to [`into_vec`](crate::StaticVec::into_vec).
   #[inline(always)]
@@ -794,9 +794,8 @@ impl_partial_ord_with_as_slice_against_slice!(&mut [T1], StaticVec<T2, N>);
 
 /// Read from a StaticVec. This implementation operates by copying bytes into the destination
 /// buffers, then shifting the remaining bytes over.
-///
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<const N: usize> Read for StaticVec<u8, N> {
   #[inline]
   fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
@@ -901,8 +900,8 @@ impl<const N: usize> Read for StaticVec<u8, N> {
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<const N: usize> Write for StaticVec<u8, N> {
   #[inline]
   fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -942,8 +941,8 @@ impl<const N: usize> Write for StaticVec<u8, N> {
   }
 }
 
-/// **Note:** this is only available when the `std` crate feature is enabled.
 #[cfg(feature = "std")]
+#[doc(cfg(feature = "std"))]
 impl<const N: usize> BufRead for StaticVec<u8, N> {
   #[inline(always)]
   fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -956,7 +955,8 @@ impl<const N: usize> BufRead for StaticVec<u8, N> {
   }
 }
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
+#[doc(cfg(feature = "serde"))]
 impl<'de, T, const N: usize> Deserialize<'de> for StaticVec<T, N>
 where T: Deserialize<'de>
 {
@@ -993,7 +993,8 @@ where T: Deserialize<'de>
   }
 }
 
-#[cfg(feature = "serde_support")]
+#[cfg(feature = "serde")]
+#[doc(cfg(feature = "serde"))]
 impl<T, const N: usize> Serialize for StaticVec<T, N>
 where T: Serialize
 {

src/utils.rs

@@ -126,7 +126,7 @@ pub(crate) fn partial_compare<T1, T2: PartialOrd<T1>>(
 /// A simple quicksort function for internal use, called in
 /// ['quicksorted_unstable`](crate::StaticVec::quicksorted_unstable).
 #[inline]
-pub(crate) fn quicksort_internal<T: Copy + PartialOrd>(
+pub(crate) const fn quicksort_internal<T: Copy + ~const PartialOrd>(
   values: *mut T,
   mut low: isize,
   mut high: isize,