Moved Bytes interface to dcb-bytes crate.

Instead of implementing `Bytes for Option<T>`, a proxy is now used, as `dcb-bytes` is in a separate crate.

dcb-bytes/src/bytes.rs

@@ -0,0 +1,39 @@
+//! Interface for converting various structures to and from bytes
+
+// Imports
+use std::error::Error;
+
+/// Conversions to and from bytes for the game file
+pub trait Bytes
+where
+	Self: Sized,
+{
+	/// The type of array required by this structure
+	type ByteArray: ByteArray;
+
+	/// The error type used for the operation
+	type FromError: Error;
+
+	/// The error type used for the operation
+	type ToError: Error;
+
+	/// Constructs this structure from `bytes`
+	fn from_bytes(bytes: &Self::ByteArray) -> Result<Self, Self::FromError>;
+
+	/// Writes this structure to `bytes`
+	fn to_bytes(&self, bytes: &mut Self::ByteArray) -> Result<(), Self::ToError>;
+}
+
+/// A trait for restricting `Bytes::ByteArray`
+pub trait ByteArray {
+	/// Size of this array
+	const SIZE: usize;
+}
+
+impl<const N: usize> ByteArray for [u8; N] {
+	const SIZE: usize = N;
+}
+
+impl ByteArray for u8 {
+	const SIZE: usize = 1;
+}

dcb-bytes/src/lib.rs

@@ -0,0 +1,62 @@
+//! Bytes conversions for [`dcb`].
+
+// Features
+#![feature(unsafe_block_in_unsafe_fn, min_const_generics)]
+// Lints
+#![warn(clippy::restriction, clippy::pedantic, clippy::nursery)]
+// Instead of `unwrap`, we must use `expect` and provide a reason
+#![forbid(clippy::unwrap_used)]
+// We must use `unsafe` in unsafe `fn`s and specify if the guarantee is
+// made by the caller or by us.
+#![forbid(unsafe_op_in_unsafe_fn)]
+// We'll disable the ones we don't need
+#![allow(clippy::blanket_clippy_restriction_lints)]
+// Necessary items may be inlined using `LTO`, so we don't need to mark them as inline
+#![allow(clippy::missing_inline_in_public_items)]
+// We prefer tail returns where possible, as they help with code readability in most cases.
+#![allow(clippy::implicit_return)]
+// We're fine with shadowing, as long as the variable is used for the same purpose.
+// Hence why `clippy::shadow_unrelated` isn't allowed.
+#![allow(clippy::shadow_reuse, clippy::shadow_same)]
+// We panic when we know it won't happen, or if it does happen, then a panic is the best option
+#![allow(clippy::panic, clippy::expect_used, clippy::unreachable, clippy::todo)]
+// We use `expect` even in functions that return a `Result` / `Option` if there is a logic error
+#![allow(clippy::unwrap_in_result)]
+// We find it more important to be able to copy paste literals such as `0xabcd1234` than
+// being able to read them, which does not provide many benefits
+#![allow(clippy::unreadable_literal, clippy::unseparated_literal_suffix)]
+// We separate implementations per their functionality usually, such as constructors, getters, setters, and others.
+#![allow(clippy::multiple_inherent_impl)]
+// Many operations we need to repeat, and to keep symmetry
+#![allow(clippy::identity_op)]
+// We only introduce items before their first usage, which sometimes is half-way through the code.
+// We make sure that we only use the item after introduced, however.
+#![allow(clippy::items_after_statements)]
+// Useful for when they either change a lot with new variants / data,
+// or for symmetry purposes
+#![allow(clippy::match_same_arms)]
+// In this library we have very grain-level error types, each function
+// will have it's own error type ideally, so any errors are explicit
+// by the type, without needing a section for them
+#![allow(clippy::missing_errors_doc)]
+// Although we generally try to avoid this, this can happen due to our module organization.
+// In the future, this lint should be removed globally and only enabled for modules which
+// actually require the use of it.
+#![allow(clippy::module_inception, clippy::module_name_repetitions)]
+// We use integer arithmetic and operations with the correct intent
+#![allow(clippy::integer_arithmetic, clippy::integer_division)]
+// We prefer using match ergonomic where possible
+#![allow(clippy::pattern_type_mismatch)]
+// Sometimes the blocks make it easier to invert their order
+#![allow(clippy::if_not_else)]
+// False positives:
+// TODO: Remove them in the future once they are no longer triggered.
+// We only slice arrays, which are verified at compile time. This
+// lint currently triggers for `&[T; N]`, which we pass around a lot.
+#![allow(clippy::indexing_slicing)]
+
+// Modules
+pub mod bytes;
+
+// Exports
+pub use bytes::{ByteArray, Bytes};