Add v3-preview back to its own crate (#139)

This is the follow-up of #120.

Author: ia0

lib/v3/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+## 0.1.0

lib/v3/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "data-encoding-v3"
+version = "0.1.0"
+authors = ["Julien Cretin <[email protected]>"]
+license = "MIT"
+edition = "2024"
+rust-version = "1.85"
+keywords = ["no_std", "base64", "base32", "hex"]
+categories = ["encoding", "no-std"]
+readme = "README.md"
+repository = "https://github.com/ia0/data-encoding"
+documentation = "https://docs.rs/data-encoding"
+description = "Development branch of data-encoding 3.0.0"
+include = ["Cargo.toml", "LICENSE", "README.md", "src/lib.rs"]
+
+# TODO(https://github.com/rust-lang/rust/issues/43781): Remove this once doc_auto_cfg is in the MSRV.
+[package.metadata.docs.rs]
+rustdoc-args = ["--cfg=docsrs"]
+
+[features]
+default = ["std"]
+alloc = []
+std = ["alloc"]
+
+[lints]
+rust.elided-lifetimes-in-paths = "warn"
+rust.let-underscore-drop = "warn"
+rust.missing-debug-implementations = "warn"
+rust.missing-docs = "warn"
+rust.unreachable-pub = "warn"
+rust.unused-results = "warn"
+clippy.pedantic = { level = "warn", priority = -1 }
+clippy.assigning-clones = "allow"
+clippy.doc-markdown = "allow"
+clippy.enum-glob-use = "allow"
+clippy.match-bool = "allow"
+clippy.semicolon-if-nothing-returned = "allow"
+clippy.similar-names = "allow"

lib/v3/LICENSE

@@ -0,0 +1 @@
+../../LICENSE

lib/v3/README.md

@@ -0,0 +1,36 @@
+:warning: It is strongly **discouraged** to use this crate _at this time_. There are no guarantees
+whatsoever (correctness, stability, documentation, etc). This warning will be updated as new
+versions are published.
+
+This crate is the development branch of `[email protected]`. It is provided as a workaround to the
+[Cargo pre-release issues](https://github.com/rust-lang/cargo/issues/2222#issuecomment-2509149376).
+It will obey the following rules:
+- The initial version is `[email protected]`
+- The final version is `[email protected]`
+- Version `[email protected]` represents `[email protected]`
+- Version `[email protected]` corresponds to `[email protected]`
+- Only the final version will be published to `data-encoding`
+
+In particular, the `data-encoding` crate won't have any `3.0.0` pre-release version. This crate
+should be used instead. To minimize code changes (v3 won't break simple usages of v2), you can
+modify your `Cargo.toml` from using `data-encoding`:
+
+```toml
+[dependencies]
+data-encoding = "2.9.0"
+```
+
+to using `data-encoding-v3` while preserving the crate name:
+
+```toml
+[dependencies]
+data-encoding = { package = "data-encoding-v3", version = "0.1.0" }
+```
+
+When `data-encoding-v3` reaches `1.0.0`, then `data-encoding` will reach `3.0.0` too, and the
+`Cargo.toml` should use `data-encoding` again:
+
+```toml
+[dependencies]
+data-encoding = "3.0.0"
+```

lib/v3/benches/lib.rs

@@ -0,0 +1,179 @@
+#![feature(test)]
+#![allow(missing_docs)]
+
+extern crate test;
+
+use data_encoding_v3 as constants;
+use data_encoding_v3::{Bit1, Bit2, Bit3, Bit6, Encoding, False, Specification, True};
+use test::Bencher;
+
+#[bench]
+fn base02_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 32768];
+    let mut spec = Specification::new();
+    spec.symbols.push_str("01");
+    let base = spec.encoding().unwrap();
+    let base = Encoding::<Bit1, True, False, False, False>::try_from(base).unwrap();
+    b.iter(|| base.encode_mut(input, output));
+}
+
+#[bench]
+fn base02_decode_base(b: &mut Bencher) {
+    let input = &[b'0'; 4096];
+    let output = &mut [0u8; 512];
+    let mut spec = Specification::new();
+    spec.symbols.push_str("01");
+    let base = spec.encoding().unwrap();
+    let base = Encoding::<Bit1, True, False, False, False>::try_from(base).unwrap();
+    b.iter(|| base.decode_mut(input, output));
+}
+
+#[bench]
+fn base04_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 16384];
+    let mut spec = Specification::new();
+    spec.symbols.push_str("0123");
+    let base = spec.encoding().unwrap();
+    let base = Encoding::<Bit2, True, False, False, False>::try_from(base).unwrap();
+    b.iter(|| base.encode_mut(input, output));
+}
+
+#[bench]
+fn base04_decode_base(b: &mut Bencher) {
+    let input = &[b'0'; 4096];
+    let output = &mut [0u8; 1024];
+    let mut spec = Specification::new();
+    spec.symbols.push_str("0123");
+    let base = spec.encoding().unwrap();
+    let base = Encoding::<Bit2, True, False, False, False>::try_from(base).unwrap();
+    b.iter(|| base.decode_mut(input, output));
+}
+
+#[bench]
+fn base08_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 10923];
+    let mut spec = Specification::new();
+    spec.symbols.push_str("01234567");
+    let base = spec.encoding().unwrap();
+    let base = Encoding::<Bit3, True, False, False, False>::try_from(base).unwrap();
+    b.iter(|| base.encode_mut(input, output));
+}
+
+#[bench]
+fn base08_decode_base(b: &mut Bencher) {
+    let input = &[b'0'; 4096];
+    let output = &mut [0u8; 1536];
+    let mut spec = Specification::new();
+    spec.symbols.push_str("01234567");
+    let base = spec.encoding().unwrap();
+    let base = Encoding::<Bit3, True, False, False, False>::try_from(base).unwrap();
+    b.iter(|| base.decode_mut(input, output));
+}
+
+#[bench]
+fn base16_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 8192];
+    b.iter(|| constants::HEXLOWER.encode_mut(input, output));
+}
+
+#[bench]
+fn base16_decode_base(b: &mut Bencher) {
+    let input = &[b'0'; 4096];
+    let output = &mut [0u8; 2048];
+    b.iter(|| constants::HEXLOWER.decode_mut(input, output));
+}
+
+#[bench]
+fn base32_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 6560];
+    b.iter(|| constants::BASE32.encode_mut(input, output));
+}
+
+#[bench]
+fn base32_decode_base(b: &mut Bencher) {
+    let input = &[b'A'; 4096];
+    let output = &mut [0u8; 2560];
+    b.iter(|| constants::BASE32.decode_mut(input, output));
+}
+
+#[bench]
+fn base64_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 5462];
+    b.iter(|| constants::BASE64_NOPAD.encode_mut(input, output));
+}
+
+#[bench]
+fn base64_decode_base(b: &mut Bencher) {
+    let input = &[b'A'; 4096];
+    let output = &mut [0u8; 3072];
+    b.iter(|| constants::BASE64_NOPAD.decode_mut(input, output));
+}
+
+#[bench]
+fn base64_encode_pad(b: &mut Bencher) {
+    let input = &mut [b'A'; 4096];
+    let output = &mut [0u8; 5464];
+    b.iter(|| constants::BASE64.encode_mut(input, output));
+}
+
+#[bench]
+fn base64_decode_pad(b: &mut Bencher) {
+    let input = &mut [b'A'; 4096];
+    for i in 0 .. 20 {
+        let x = 4096 * i / 20 / 4 * 4;
+        input[x + 3] = b'=';
+        if i % 2 == 0 {
+            input[x + 2] = b'=';
+        }
+    }
+    let output = &mut [0u8; 3072];
+    b.iter(|| constants::BASE64.decode_mut(input, output).unwrap());
+}
+
+#[bench]
+fn base64_encode_wrap(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 5608];
+    let mut spec = constants::BASE64.specification();
+    spec.wrap.width = 76;
+    spec.wrap.separator.push_str("\r\n");
+    let base64 = spec.encoding().unwrap();
+    let base64 = Encoding::<Bit6, True, True, True, True>::try_from(base64).unwrap();
+    b.iter(|| base64.encode_mut(input, output));
+}
+
+#[bench]
+fn base64_decode_wrap(b: &mut Bencher) {
+    let input = &mut [b'A'; 4096];
+    for i in 0 .. 20 {
+        let x = 4096 * i / 20 / 4 * 4;
+        input[x + 3] = b'\n';
+    }
+    let output = &mut [0u8; 3072];
+    let mut spec = constants::BASE64.specification();
+    spec.wrap.width = 76;
+    spec.wrap.separator.push_str("\r\n");
+    let base64 = spec.encoding().unwrap();
+    let base64 = Encoding::<Bit6, True, True, True, True>::try_from(base64).unwrap();
+    b.iter(|| base64.decode_mut(input, output).unwrap());
+}
+
+#[bench]
+fn dnscurve_decode_base(b: &mut Bencher) {
+    let input = &[b'0'; 4096];
+    let output = &mut [0u8; 2560];
+    b.iter(|| constants::BASE32_DNSCURVE.decode_mut(input, output));
+}
+
+#[bench]
+fn dnscurve_encode_base(b: &mut Bencher) {
+    let input = &[0u8; 4096];
+    let output = &mut [0u8; 6554];
+    b.iter(|| constants::BASE32_DNSCURVE.encode_mut(input, output));
+}