Use enums for runestone tags and flags (ordinals#2956)

src/runes.rs

@@ -1,4 +1,7 @@
-use super::*;
+use {
+  self::{flag::Flag, tag::Tag},
+  super::*,
+};
 
 pub use {edict::Edict, rune::Rune, rune_id::RuneId, runestone::Runestone};
 
@@ -11,11 +14,13 @@ const RESERVED: u128 = 6402364363415443603228541259936211926;
 
 mod edict;
 mod etching;
+mod flag;
 mod pile;
 mod rune;
 mod rune_id;
 mod runestone;
 mod spaced_rune;
+mod tag;
 pub mod varint;
 
 type Result<T, E = Error> = std::result::Result<T, E>;

src/runes/etching.rs

@@ -6,7 +6,7 @@ pub struct Etching {
   pub divisibility: u8,
   pub limit: Option<u128>,
   pub rune: Option<Rune>,
+  pub spacers: u32,
   pub symbol: Option<char>,
   pub term: Option<u32>,
-  pub spacers: u32,
 }

src/runes/flag.rs

@@ -0,0 +1,51 @@
+pub(super) enum Flag {
+  Etch = 0,
+  #[allow(unused)]
+  Burn = 127,
+}
+
+impl Flag {
+  pub(super) fn mask(self) -> u128 {
+    1 << self as u128
+  }
+
+  pub(super) fn take(self, flags: &mut u128) -> bool {
+    let mask = self.mask();
+    let set = *flags & mask != 0;
+    *flags &= !mask;
+    set
+  }
+
+  pub(super) fn set(self, flags: &mut u128) {
+    *flags |= self.mask()
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn mask() {
+    assert_eq!(Flag::Etch.mask(), 0b1);
+    assert_eq!(Flag::Burn.mask(), 1 << 127);
+  }
+
+  #[test]
+  fn take() {
+    let mut flags = 1;
+    assert!(Flag::Etch.take(&mut flags));
+    assert_eq!(flags, 0);
+
+    let mut flags = 0;
+    assert!(!Flag::Etch.take(&mut flags));
+    assert_eq!(flags, 0);
+  }
+
+  #[test]
+  fn set() {
+    let mut flags = 0;
+    Flag::Etch.set(&mut flags);
+    assert_eq!(flags, 1);
+  }
+}