From 66df7fb8ada572fd2edca6c6e1d67feb25384530 Mon Sep 17 00:00:00 2001 From: tison Date: Sat, 25 Jul 2026 21:06:48 +0800 Subject: [PATCH] refactor: use cfg predicates in macroweave rows --- bsize/src/impls/stable.rs | 197 +++++++++++++++--------------------- bsize/src/traits/nightly.rs | 52 ++++------ bsize/src/traits/stable.rs | 52 ++++------ 3 files changed, 128 insertions(+), 173 deletions(-) diff --git a/bsize/src/impls/stable.rs b/bsize/src/impls/stable.rs index a8b666c..6f14315 100644 --- a/bsize/src/impls/stable.rs +++ b/bsize/src/impls/stable.rs @@ -22,28 +22,49 @@ impl ByteSize { } } -macroweave::repeat!((Ty, Name, Trait, Size) in [ - (u16, kb, KiloByteSize, KB), - (u16, kib, KiloByteSize, KIB), - (u32, kb, KiloByteSize, KB), - (u32, kib, KiloByteSize, KIB), - (u32, mb, MegaByteSize, MB), - (u32, mib, MegaByteSize, MIB), - (u32, gb, GigaByteSize, GB), - (u32, gib, GigaByteSize, GIB), - (u64, kb, KiloByteSize, KB), - (u64, kib, KiloByteSize, KIB), - (u64, mb, MegaByteSize, MB), - (u64, mib, MegaByteSize, MIB), - (u64, gb, GigaByteSize, GB), - (u64, gib, GigaByteSize, GIB), - (u64, tb, TeraByteSize, TB), - (u64, tib, TeraByteSize, TIB), - (u64, pb, PetaByteSize, PB), - (u64, pib, PetaByteSize, PIB), - (u64, eb, ExaByteSize, EB), - (u64, eib, ExaByteSize, EIB), +macroweave::repeat!((Cfg, Ty, Name, Trait, Size) in [ + (all(), u16, kb, KiloByteSize, KB), + (all(), u16, kib, KiloByteSize, KIB), + (all(), u32, kb, KiloByteSize, KB), + (all(), u32, kib, KiloByteSize, KIB), + (all(), u32, mb, MegaByteSize, MB), + (all(), u32, mib, MegaByteSize, MIB), + (all(), u32, gb, GigaByteSize, GB), + (all(), u32, gib, GigaByteSize, GIB), + (all(), u64, kb, KiloByteSize, KB), + (all(), u64, kib, KiloByteSize, KIB), + (all(), u64, mb, MegaByteSize, MB), + (all(), u64, mib, MegaByteSize, MIB), + (all(), u64, gb, GigaByteSize, GB), + (all(), u64, gib, GigaByteSize, GIB), + (all(), u64, tb, TeraByteSize, TB), + (all(), u64, tib, TeraByteSize, TIB), + (all(), u64, pb, PetaByteSize, PB), + (all(), u64, pib, PetaByteSize, PIB), + (all(), u64, eb, ExaByteSize, EB), + (all(), u64, eib, ExaByteSize, EIB), + (target_pointer_width = "16", usize, kb, KiloByteSize, KB), + (target_pointer_width = "16", usize, kib, KiloByteSize, KIB), + (target_pointer_width = "32", usize, kb, KiloByteSize, KB), + (target_pointer_width = "32", usize, kib, KiloByteSize, KIB), + (target_pointer_width = "32", usize, mb, MegaByteSize, MB), + (target_pointer_width = "32", usize, mib, MegaByteSize, MIB), + (target_pointer_width = "32", usize, gb, GigaByteSize, GB), + (target_pointer_width = "32", usize, gib, GigaByteSize, GIB), + (target_pointer_width = "64", usize, kb, KiloByteSize, KB), + (target_pointer_width = "64", usize, kib, KiloByteSize, KIB), + (target_pointer_width = "64", usize, mb, MegaByteSize, MB), + (target_pointer_width = "64", usize, mib, MegaByteSize, MIB), + (target_pointer_width = "64", usize, gb, GigaByteSize, GB), + (target_pointer_width = "64", usize, gib, GigaByteSize, GIB), + (target_pointer_width = "64", usize, tb, TeraByteSize, TB), + (target_pointer_width = "64", usize, tib, TeraByteSize, TIB), + (target_pointer_width = "64", usize, pb, PetaByteSize, PB), + (target_pointer_width = "64", usize, pib, PetaByteSize, PIB), + (target_pointer_width = "64", usize, eb, ExaByteSize, EB), + (target_pointer_width = "64", usize, eib, ExaByteSize, EIB), ] { + #[cfg(Cfg)] impl ByteSize { #[doc = concat!( "Constructs a byte size wrapper from a quantity of `", @@ -57,42 +78,6 @@ macroweave::repeat!((Ty, Name, Trait, Size) in [ } }); -macroweave::repeat!((PointerWidth, Name, Trait, Size) in [ - ("16", kb, KiloByteSize, KB), - ("16", kib, KiloByteSize, KIB), - ("32", kb, KiloByteSize, KB), - ("32", kib, KiloByteSize, KIB), - ("32", mb, MegaByteSize, MB), - ("32", mib, MegaByteSize, MIB), - ("32", gb, GigaByteSize, GB), - ("32", gib, GigaByteSize, GIB), - ("64", kb, KiloByteSize, KB), - ("64", kib, KiloByteSize, KIB), - ("64", mb, MegaByteSize, MB), - ("64", mib, MegaByteSize, MIB), - ("64", gb, GigaByteSize, GB), - ("64", gib, GigaByteSize, GIB), - ("64", tb, TeraByteSize, TB), - ("64", tib, TeraByteSize, TIB), - ("64", pb, PetaByteSize, PB), - ("64", pib, PetaByteSize, PIB), - ("64", eb, ExaByteSize, EB), - ("64", eib, ExaByteSize, EIB), -] { - #[cfg(target_pointer_width = PointerWidth)] - impl ByteSize { - #[doc = concat!( - "Constructs a byte size wrapper from a quantity of `", - stringify!(Name), - "` units." - )] - #[inline(always)] - pub const fn Name(size: usize) -> Self { - ByteSize(size * ::Size) - } - } -}); - macroweave::repeat!(Ty in [u8, u16, u32, u64, usize] { impl ByteSize { /// Returns byte count as bytes. @@ -107,28 +92,49 @@ macroweave::repeat!(Ty in [u8, u16, u32, u64, usize] { } }); -macroweave::repeat!((Ty, Name, Trait, Size, Unit) in [ - (u16, as_kb, KiloByteSize, KB, "kilobytes"), - (u16, as_kib, KiloByteSize, KIB, "kibibytes"), - (u32, as_kb, KiloByteSize, KB, "kilobytes"), - (u32, as_kib, KiloByteSize, KIB, "kibibytes"), - (u32, as_mb, MegaByteSize, MB, "megabytes"), - (u32, as_mib, MegaByteSize, MIB, "mebibytes"), - (u32, as_gb, GigaByteSize, GB, "gigabytes"), - (u32, as_gib, GigaByteSize, GIB, "gibibytes"), - (u64, as_kb, KiloByteSize, KB, "kilobytes"), - (u64, as_kib, KiloByteSize, KIB, "kibibytes"), - (u64, as_mb, MegaByteSize, MB, "megabytes"), - (u64, as_mib, MegaByteSize, MIB, "mebibytes"), - (u64, as_gb, GigaByteSize, GB, "gigabytes"), - (u64, as_gib, GigaByteSize, GIB, "gibibytes"), - (u64, as_tb, TeraByteSize, TB, "terabytes"), - (u64, as_tib, TeraByteSize, TIB, "tebibytes"), - (u64, as_pb, PetaByteSize, PB, "petabytes"), - (u64, as_pib, PetaByteSize, PIB, "pebibytes"), - (u64, as_eb, ExaByteSize, EB, "exabytes"), - (u64, as_eib, ExaByteSize, EIB, "exbibytes"), +macroweave::repeat!((Cfg, Ty, Name, Trait, Size, Unit) in [ + (all(), u16, as_kb, KiloByteSize, KB, "kilobytes"), + (all(), u16, as_kib, KiloByteSize, KIB, "kibibytes"), + (all(), u32, as_kb, KiloByteSize, KB, "kilobytes"), + (all(), u32, as_kib, KiloByteSize, KIB, "kibibytes"), + (all(), u32, as_mb, MegaByteSize, MB, "megabytes"), + (all(), u32, as_mib, MegaByteSize, MIB, "mebibytes"), + (all(), u32, as_gb, GigaByteSize, GB, "gigabytes"), + (all(), u32, as_gib, GigaByteSize, GIB, "gibibytes"), + (all(), u64, as_kb, KiloByteSize, KB, "kilobytes"), + (all(), u64, as_kib, KiloByteSize, KIB, "kibibytes"), + (all(), u64, as_mb, MegaByteSize, MB, "megabytes"), + (all(), u64, as_mib, MegaByteSize, MIB, "mebibytes"), + (all(), u64, as_gb, GigaByteSize, GB, "gigabytes"), + (all(), u64, as_gib, GigaByteSize, GIB, "gibibytes"), + (all(), u64, as_tb, TeraByteSize, TB, "terabytes"), + (all(), u64, as_tib, TeraByteSize, TIB, "tebibytes"), + (all(), u64, as_pb, PetaByteSize, PB, "petabytes"), + (all(), u64, as_pib, PetaByteSize, PIB, "pebibytes"), + (all(), u64, as_eb, ExaByteSize, EB, "exabytes"), + (all(), u64, as_eib, ExaByteSize, EIB, "exbibytes"), + (target_pointer_width = "16", usize, as_kb, KiloByteSize, KB, "kilobytes"), + (target_pointer_width = "16", usize, as_kib, KiloByteSize, KIB, "kibibytes"), + (target_pointer_width = "32", usize, as_kb, KiloByteSize, KB, "kilobytes"), + (target_pointer_width = "32", usize, as_kib, KiloByteSize, KIB, "kibibytes"), + (target_pointer_width = "32", usize, as_mb, MegaByteSize, MB, "megabytes"), + (target_pointer_width = "32", usize, as_mib, MegaByteSize, MIB, "mebibytes"), + (target_pointer_width = "32", usize, as_gb, GigaByteSize, GB, "gigabytes"), + (target_pointer_width = "32", usize, as_gib, GigaByteSize, GIB, "gibibytes"), + (target_pointer_width = "64", usize, as_kb, KiloByteSize, KB, "kilobytes"), + (target_pointer_width = "64", usize, as_kib, KiloByteSize, KIB, "kibibytes"), + (target_pointer_width = "64", usize, as_mb, MegaByteSize, MB, "megabytes"), + (target_pointer_width = "64", usize, as_mib, MegaByteSize, MIB, "mebibytes"), + (target_pointer_width = "64", usize, as_gb, GigaByteSize, GB, "gigabytes"), + (target_pointer_width = "64", usize, as_gib, GigaByteSize, GIB, "gibibytes"), + (target_pointer_width = "64", usize, as_tb, TeraByteSize, TB, "terabytes"), + (target_pointer_width = "64", usize, as_tib, TeraByteSize, TIB, "tebibytes"), + (target_pointer_width = "64", usize, as_pb, PetaByteSize, PB, "petabytes"), + (target_pointer_width = "64", usize, as_pib, PetaByteSize, PIB, "pebibytes"), + (target_pointer_width = "64", usize, as_eb, ExaByteSize, EB, "exabytes"), + (target_pointer_width = "64", usize, as_eib, ExaByteSize, EIB, "exbibytes"), ] { + #[cfg(Cfg)] impl ByteSize { #[doc = concat!("Returns byte count as ", Unit, ".")] /// @@ -140,38 +146,3 @@ macroweave::repeat!((Ty, Name, Trait, Size, Unit) in [ } } }); - -macroweave::repeat!((PointerWidth, Name, Trait, Size, Unit) in [ - ("16", as_kb, KiloByteSize, KB, "kilobytes"), - ("16", as_kib, KiloByteSize, KIB, "kibibytes"), - ("32", as_kb, KiloByteSize, KB, "kilobytes"), - ("32", as_kib, KiloByteSize, KIB, "kibibytes"), - ("32", as_mb, MegaByteSize, MB, "megabytes"), - ("32", as_mib, MegaByteSize, MIB, "mebibytes"), - ("32", as_gb, GigaByteSize, GB, "gigabytes"), - ("32", as_gib, GigaByteSize, GIB, "gibibytes"), - ("64", as_kb, KiloByteSize, KB, "kilobytes"), - ("64", as_kib, KiloByteSize, KIB, "kibibytes"), - ("64", as_mb, MegaByteSize, MB, "megabytes"), - ("64", as_mib, MegaByteSize, MIB, "mebibytes"), - ("64", as_gb, GigaByteSize, GB, "gigabytes"), - ("64", as_gib, GigaByteSize, GIB, "gibibytes"), - ("64", as_tb, TeraByteSize, TB, "terabytes"), - ("64", as_tib, TeraByteSize, TIB, "tebibytes"), - ("64", as_pb, PetaByteSize, PB, "petabytes"), - ("64", as_pib, PetaByteSize, PIB, "pebibytes"), - ("64", as_eb, ExaByteSize, EB, "exabytes"), - ("64", as_eib, ExaByteSize, EIB, "exbibytes"), -] { - #[cfg(target_pointer_width = PointerWidth)] - impl ByteSize { - #[doc = concat!("Returns byte count as ", Unit, ".")] - /// - /// The result is approximate when the byte count cannot be - /// represented exactly as `f64`. - #[inline(always)] - pub const fn Name(&self) -> f64 { - (self.0 as f64) / (::Size as f64) - } - } -}); diff --git a/bsize/src/traits/nightly.rs b/bsize/src/traits/nightly.rs index 54d1afb..abcd21c 100644 --- a/bsize/src/traits/nightly.rs +++ b/bsize/src/traits/nightly.rs @@ -86,39 +86,31 @@ macroweave::repeat!(Ty in [u8, u16, u32, u64, usize] { } }); -macroweave::repeat!((Trait, Ty, DecimalName, BinaryName, Scale) in [ - (KiloByteSize, u16, KB, KIB, 1), - (KiloByteSize, u32, KB, KIB, 1), - (MegaByteSize, u32, MB, MIB, 2), - (GigaByteSize, u32, GB, GIB, 3), - (KiloByteSize, u64, KB, KIB, 1), - (MegaByteSize, u64, MB, MIB, 2), - (GigaByteSize, u64, GB, GIB, 3), - (TeraByteSize, u64, TB, TIB, 4), - (PetaByteSize, u64, PB, PIB, 5), - (ExaByteSize, u64, EB, EIB, 6), +macroweave::repeat!((Cfg, Trait, Ty, DecimalName, BinaryName, Scale) in [ + (all(), KiloByteSize, u16, KB, KIB, 1), + (all(), KiloByteSize, u32, KB, KIB, 1), + (all(), MegaByteSize, u32, MB, MIB, 2), + (all(), GigaByteSize, u32, GB, GIB, 3), + (all(), KiloByteSize, u64, KB, KIB, 1), + (all(), MegaByteSize, u64, MB, MIB, 2), + (all(), GigaByteSize, u64, GB, GIB, 3), + (all(), TeraByteSize, u64, TB, TIB, 4), + (all(), PetaByteSize, u64, PB, PIB, 5), + (all(), ExaByteSize, u64, EB, EIB, 6), + (target_pointer_width = "16", KiloByteSize, usize, KB, KIB, 1), + (target_pointer_width = "32", KiloByteSize, usize, KB, KIB, 1), + (target_pointer_width = "32", MegaByteSize, usize, MB, MIB, 2), + (target_pointer_width = "32", GigaByteSize, usize, GB, GIB, 3), + (target_pointer_width = "64", KiloByteSize, usize, KB, KIB, 1), + (target_pointer_width = "64", MegaByteSize, usize, MB, MIB, 2), + (target_pointer_width = "64", GigaByteSize, usize, GB, GIB, 3), + (target_pointer_width = "64", TeraByteSize, usize, TB, TIB, 4), + (target_pointer_width = "64", PetaByteSize, usize, PB, PIB, 5), + (target_pointer_width = "64", ExaByteSize, usize, EB, EIB, 6), ] { + #[cfg(Cfg)] const impl Trait for Ty { const DecimalName: Self = Ty::pow(1000, Scale); const BinaryName: Self = Ty::pow(1024, Scale); } }); - -macroweave::repeat!((PointerWidth, Trait, DecimalName, BinaryName, Scale) in [ - ("16", KiloByteSize, KB, KIB, 1), - ("32", KiloByteSize, KB, KIB, 1), - ("32", MegaByteSize, MB, MIB, 2), - ("32", GigaByteSize, GB, GIB, 3), - ("64", KiloByteSize, KB, KIB, 1), - ("64", MegaByteSize, MB, MIB, 2), - ("64", GigaByteSize, GB, GIB, 3), - ("64", TeraByteSize, TB, TIB, 4), - ("64", PetaByteSize, PB, PIB, 5), - ("64", ExaByteSize, EB, EIB, 6), -] { - #[cfg(target_pointer_width = PointerWidth)] - const impl Trait for usize { - const DecimalName: Self = usize::pow(1000, Scale); - const BinaryName: Self = usize::pow(1024, Scale); - } -}); diff --git a/bsize/src/traits/stable.rs b/bsize/src/traits/stable.rs index 30dfb29..f948c73 100644 --- a/bsize/src/traits/stable.rs +++ b/bsize/src/traits/stable.rs @@ -86,39 +86,31 @@ macroweave::repeat!(Ty in [u8, u16, u32, u64, usize] { } }); -macroweave::repeat!((Trait, Ty, DecimalName, BinaryName, Scale) in [ - (KiloByteSize, u16, KB, KIB, 1), - (KiloByteSize, u32, KB, KIB, 1), - (MegaByteSize, u32, MB, MIB, 2), - (GigaByteSize, u32, GB, GIB, 3), - (KiloByteSize, u64, KB, KIB, 1), - (MegaByteSize, u64, MB, MIB, 2), - (GigaByteSize, u64, GB, GIB, 3), - (TeraByteSize, u64, TB, TIB, 4), - (PetaByteSize, u64, PB, PIB, 5), - (ExaByteSize, u64, EB, EIB, 6), +macroweave::repeat!((Cfg, Trait, Ty, DecimalName, BinaryName, Scale) in [ + (all(), KiloByteSize, u16, KB, KIB, 1), + (all(), KiloByteSize, u32, KB, KIB, 1), + (all(), MegaByteSize, u32, MB, MIB, 2), + (all(), GigaByteSize, u32, GB, GIB, 3), + (all(), KiloByteSize, u64, KB, KIB, 1), + (all(), MegaByteSize, u64, MB, MIB, 2), + (all(), GigaByteSize, u64, GB, GIB, 3), + (all(), TeraByteSize, u64, TB, TIB, 4), + (all(), PetaByteSize, u64, PB, PIB, 5), + (all(), ExaByteSize, u64, EB, EIB, 6), + (target_pointer_width = "16", KiloByteSize, usize, KB, KIB, 1), + (target_pointer_width = "32", KiloByteSize, usize, KB, KIB, 1), + (target_pointer_width = "32", MegaByteSize, usize, MB, MIB, 2), + (target_pointer_width = "32", GigaByteSize, usize, GB, GIB, 3), + (target_pointer_width = "64", KiloByteSize, usize, KB, KIB, 1), + (target_pointer_width = "64", MegaByteSize, usize, MB, MIB, 2), + (target_pointer_width = "64", GigaByteSize, usize, GB, GIB, 3), + (target_pointer_width = "64", TeraByteSize, usize, TB, TIB, 4), + (target_pointer_width = "64", PetaByteSize, usize, PB, PIB, 5), + (target_pointer_width = "64", ExaByteSize, usize, EB, EIB, 6), ] { + #[cfg(Cfg)] impl Trait for Ty { const DecimalName: Self = Ty::pow(1000, Scale); const BinaryName: Self = Ty::pow(1024, Scale); } }); - -macroweave::repeat!((PointerWidth, Trait, DecimalName, BinaryName, Scale) in [ - ("16", KiloByteSize, KB, KIB, 1), - ("32", KiloByteSize, KB, KIB, 1), - ("32", MegaByteSize, MB, MIB, 2), - ("32", GigaByteSize, GB, GIB, 3), - ("64", KiloByteSize, KB, KIB, 1), - ("64", MegaByteSize, MB, MIB, 2), - ("64", GigaByteSize, GB, GIB, 3), - ("64", TeraByteSize, TB, TIB, 4), - ("64", PetaByteSize, PB, PIB, 5), - ("64", ExaByteSize, EB, EIB, 6), -] { - #[cfg(target_pointer_width = PointerWidth)] - impl Trait for usize { - const DecimalName: Self = usize::pow(1000, Scale); - const BinaryName: Self = usize::pow(1024, Scale); - } -});