Struct BmsTableHeader 

#[non_exhaustive]
pub struct BmsTableHeader {
    pub name: String,
    pub symbol: String,
    pub data_url: String,
    pub tag: Option<String>,
    pub mode: Option<String>,
    pub course: CourseGroup,
    pub level_order: Vec<String>,
    pub extra: BTreeMap<String, Value>,
}

BMS header information.

Strictly parses common fields and preserves unrecognized fields in extra for forward compatibility.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

Table name, e.g. “Satellite”

symbol: String

Table symbol, e.g. “sl”

data_url: String

URL of chart data file (preserves the original string from header JSON)

tag: Option<String>

Tag label text; use effective_tag to get the spec-mandated fallback to symbol when this is None.

mode: Option<String>

Play mode hint; same semantics as bmson’s mode_hint

course: CourseGroup

Course information, preserving the original JSON nesting shape.

Supports flat arrays ("course": [{...}]) and arbitrarily nested arrays ("course": [[{...}]], "course": [[{...}], [{...}]], etc.). Deserialized as a CourseGroup tree.

level_order: Vec<String>

Difficulty level order containing numbers and strings

extra: BTreeMap<String, Value>

Extra data (unrecognized fields from header JSON)

Implementations

impl BmsTableHeader

pub const fn new(name: String, symbol: String, data_url: String) -> Self

Creates a new BmsTableHeader with the given required fields and defaults for everything else.

pub fn level_index(&self, level: &str) -> Option<usize>

Returns the index of a level in level_order, or None if not found.

This is useful for comparing difficulty levels: a lower index means an easier level.

Note: This performs a linear scan (O(n)) on each call. For repeated lookups across many chart items, consider building a HashMap<&str, usize> from level_order once.

Example

let mut header = BmsTableHeader::new(
    "Test".into(),
    "t".into(),
    "d.json".into(),
);
header.level_order = vec!["1".into(), "2".into(), "3".into()];
assert_eq!(header.level_index("2"), Some(1));
assert_eq!(header.level_index("4"), None);

pub fn effective_tag(&self) -> &str

Returns the effective tag, falling back to symbol when tag is None.

Per the BMS difficulty table spec, the tag field should fall back to symbol when absent. This method implements that behavior.

Example

let header = BmsTableHeader::new("Table".into(), "sl".into(), "d.json".into());
assert_eq!(header.effective_tag(), "sl");

Trait Implementations

impl Clone for BmsTableHeader

fn clone(&self) -> BmsTableHeader

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BmsTableHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BmsTableHeader

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BmsTableHeader

fn eq(&self, other: &BmsTableHeader) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BmsTableHeader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BmsTableHeader