Update doc; update syn version

Author: wwylele

byte_struct/src/lib.rs

@@ -48,7 +48,7 @@
 //! }
 //! ```
 
-pub use byte_struct_derive::*;
+pub use byte_struct_derive::{ByteStruct, ByteStructBE, ByteStructLE};
 
 /// A type that can be packed into or unpacked from fixed-size bytes, but the method is unknown yet.
 pub trait ByteStructLen {
@@ -58,9 +58,9 @@ pub trait ByteStructLen {
 
 /// A data structure that can be packed into or unpacked from raw bytes.
 ///
-/// This trait can be derived by either `#[derive(ByteStructLE)]` or `#[derive(ByteStructBE)]`.
-/// The difference between two macros is byte order specification. `LE` is for little-endian,
-/// and `BE` is for big-endian. All members of the struct to derive must implement `ByteStructUnspecifiedByteOrder`.
+/// This trait can be derived by
+/// [`#[derive(ByteStruct)]`](https://docs.rs/byte_struct_derive/*/byte_struct_derive/derive.ByteStruct.html).
+///
 /// One can implement this trait for custom types in order to pack or unpack an object in a special way.
 pub trait ByteStruct: ByteStructLen {
     /// Packs the struct into raw bytes and write to a slice
@@ -78,23 +78,25 @@ pub trait ByteStruct: ByteStructLen {
 /// This is also implemented for array types whose element type implements `ByteStructUnspecifiedByteOrder`
 /// and whose size is between 1 and 32 (inclusive).
 ///
-/// This trait is automatically implemented for all types that implements `ByteStruct`.
-/// In this case, all members of `ByteStructUnspecifiedByteOrder` are direct wrappers of `ByteStruct` members.
+/// This trait is automatically implemented for all types that implements [`ByteStruct`].
+/// In this case, all members of `ByteStructUnspecifiedByteOrder` are direct wrappers of [`ByteStruct`] members.
 ///
 /// Members in this trait are meant to be called by byte_struct internal only.
 /// They do not do what one might expect:
 /// the byte orders specified in `read_bytes_default_*` / `write_bytes_default_*` functions
 /// are only **default byte orders**.
-/// The default byte order is only repected when the type itself does not carry byte order specification
+/// The default byte order is only respected when the type itself does not carry byte order specification
 /// (e.g. primitive types).
-/// In contrast, since `ByteStruct` types always have fixed packing method,
+/// In contrast, since [`ByteStruct`] types always have fixed packing method,
 /// the default byte order has no effect on them, and the three versions of read / write functions for them,
-/// `_default_le`, `_default_be` and no-spec from `ByteStruct`, behave exactly the same.
+/// `_default_le`, `_default_be` and no-spec from [`ByteStruct`], behave exactly the same.
 ///
 /// One can implement this trait for custom types in order to pack or unpack an object in a special way,
 /// but only when the said type changes its packing method depending on the default byte order.
 /// An example for this is a custom fixed-size large integer type.
-/// If the packing method is independent from the default byte order, please implement `ByteStruct` instead.
+/// If the packing method is independent from the default byte order, please implement [`ByteStruct`] instead.
+///
+/// [`ByteStruct`]: trait.ByteStruct.html
 pub trait ByteStructUnspecifiedByteOrder: ByteStructLen {
     /// Packs the object into raw bytes with little-endian as the default byte order
     fn write_bytes_default_le(&self, bytes: &mut [u8]);
@@ -110,22 +112,22 @@ pub trait ByteStructUnspecifiedByteOrder: ByteStructLen {
 }
 
 impl<T: ByteStruct> ByteStructUnspecifiedByteOrder for T {
-    /// A wrapper of `ByteStruct::write_bytes`
+    /// A wrapper of [`ByteStruct::write_bytes`](trait.ByteStruct.html#tymethod.write_bytes)
     fn write_bytes_default_le(&self, bytes: &mut [u8]) {
         self.write_bytes(bytes);
     }
 
-    /// A wrapper of `ByteStruct::read_bytes`
+    /// A wrapper of [`ByteStruct::read_bytes`](trait.ByteStruct.html#tymethod.read_bytes)
     fn read_bytes_default_le(bytes: &[u8]) -> Self {
         Self::read_bytes(bytes)
     }
 
-    /// A wrapper of `ByteStruct::write_bytes`
+    /// A wrapper of [`ByteStruct::write_bytes`](trait.ByteStruct.html#tymethod.write_bytes)
     fn write_bytes_default_be(&self, bytes: &mut [u8]) {
         self.write_bytes(bytes);
     }
 
-    /// A wrapper of `ByteStruct::read_bytes`
+    /// A wrapper of [`ByteStruct::read_bytes`](trait.ByteStruct.html#tymethod.read_bytes)
     fn read_bytes_default_be(bytes: &[u8]) -> Self {
         Self::read_bytes(bytes)
     }
@@ -452,17 +454,19 @@ bsa5!(1);
 byte_struct_array!(100);
 byte_struct_array!(3000);
 
-/// Generates a structure that implements `ByteStructUnspecifiedByteOrder` with bit field semantics.
+/// Generates a structure that implements [`ByteStructUnspecifiedByteOrder`] with bit field semantics.
 ///
 /// The bit fields are packed to / unpacked from the base integer type,
-/// which is then packed / unpacked using the primitive type's `ByteStructUnspecifiedByteOrder` implementation.
+/// which is then packed / unpacked using the primitive type's [`ByteStructUnspecifiedByteOrder`] implementation.
 /// Therefore, the byte order of bit fields is unspecified internally, and is only specified
-/// by the parent structure that derives `ByteStructLE`, `ByteStructBE`, just like all primitive
+/// by the parent structure that derives [`ByteStruct`](trait.ByteStruct.html), just like all primitive
 /// types.
 ///
 /// Note that the memory representation of the generated structure during runtime is NOT in bit field layout.
 /// This macro only provides conversion method between the plain structure and the bit-field-packed bytes.
 ///
+/// [`ByteStructUnspecifiedByteOrder`]: trait.ByteStructUnspecifiedByteOrder.html
+///
 /// # Example
 /// ```
 /// bitfields!(

byte_struct_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "byte_struct_derive"
-version = "0.4.0"
+version = "0.4.2"
 authors = ["Weiyi Wang <[email protected]>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -12,6 +12,6 @@ readme = "../README.md"
 proc-macro = true
 
 [dependencies]
-syn = "0.14.4"
+syn = "0.15.0"
 quote = "0.6.3"
 proc-macro2 = "0.4"

byte_struct_derive/src/lib.rs

@@ -1,3 +1,12 @@
+//! # Derive macro for Byte Struct
+//!
+//! This crate provides macros for deriving the [`ByteStruct`] trait
+//! defined in the [`byte_struct` crate](https://docs.rs/byte_struct).
+//!
+//! See [`#[derive(ByteStruct)]`](derive.ByteStruct.html) for using the macro.
+//!
+//! [`ByteStruct`]: https://docs.rs/byte_struct/*/byte_struct/trait.ByteStruct.html
+
 #![recursion_limit = "128"]
 extern crate proc_macro;
 
@@ -12,29 +21,32 @@ enum Endianness {
     Unspecified,
 }
 
-/// Derives trait `ByteStruct` for a data structure.
+/// Derives trait [`ByteStruct`] for a data structure.
 ///
-/// Requires all members to implement `ByteStructUnspecifiedByteOrder`.
-/// This includes most primitive types and nested structures with `ByteStruct` derived
-/// (because `ByteStruct` is automatically implemented for `ByteStructUnspecifiedByteOrder` types)
+/// Requires all members to implement [`ByteStructUnspecifiedByteOrder`].
+/// This includes most primitive types and nested structures with [`ByteStruct`] derived
+/// (because [`ByteStructUnspecifiedByteOrder`] is automatically implemented for [`ByteStruct`] types)
 ///
 /// Byte order attributes `#[byte_struct_le]` or `#[byte_struct_be]` can be attached to individual fields
 /// and/or the entire structure.
 ///
 /// When a byte order attribute are attached to a field, it selects which byte order version
-/// of `ByteStructUnspecifiedByteOrder` member functions to use on the field
+/// of [`ByteStructUnspecifiedByteOrder`] member functions to use on the field
 /// In other words, the attribute specifies the byte order on an byte-order-unspecified type.
-/// These attributes have no effect on fields that implements `ByteStruct`,
+/// These attributes have no effect on fields that implements [`ByteStruct`],
 /// because they always have the same byte packing method regardless of externally specified byte order.
 ///
 /// When a byte order attribute is attached to the entire struct,
 /// it works as if it is attached to all fields that don't have byte order attributes.
 ///
 /// If a field has no byte order attribute specified
 /// (either explicitly attached to the field or implicitly by the attribute on the entire structure),
-/// it must implement `ByteStruct` as well, so that its packing method is not byte-order-dependent.
+/// it must implement [`ByteStruct`] as well, so that its packing method is not byte-order-dependent.
 /// This is true for all `ByteStruct`-derived structures, but not for primitive types.
 ///
+/// [`ByteStruct`]: https://docs.rs/byte_struct/*/byte_struct/trait.ByteStruct.html
+/// [`ByteStructUnspecifiedByteOrder`]: https://docs.rs/byte_struct/*/byte_struct/trait.ByteStructUnspecifiedByteOrder.html
+///
 /// ## Example
 /// ```
 /// #[derive(ByteStruct)]
@@ -84,7 +96,7 @@ pub fn byte_struct_macro_derive(input: TokenStream) -> TokenStream {
     byte_struct_macro_derive_impl(input, Endianness::Unspecified)
 }
 
-/// Same effect as `#[derive(ByteStruct)] #[byte_struct_le]`
+/// Same effect as [`#[derive(ByteStruct)] #[byte_struct_le]`](derive.ByteStruct.html)
 ///
 /// But doesn't support byte order attributes on fields
 #[deprecated]
@@ -93,7 +105,7 @@ pub fn byte_struct_le_macro_derive(input: TokenStream) -> TokenStream {
     byte_struct_macro_derive_impl(input, Endianness::Little)
 }
 
-/// Same effect as `#[derive(ByteStruct)] #[byte_struct_be]`
+/// Same effect as [`#[derive(ByteStruct)] #[byte_struct_be]`](derive.ByteStruct.html)
 ///
 /// But doesn't support byte order attributes on fields
 #[deprecated]