Struct Record 

pub struct Record {

    pub version: String,
    pub producer: Option<String>,
    pub variant: Variant,
    pub score: usize,
    pub available_moves: Option<usize>,
    pub terminal: Option<bool>,
    pub bbox: Option<[i16; 4]>,
    pub saved_at: Option<String>,
    pub description: Option<String>,
    pub author: Option<String>,
    pub source: Option<String>,
    pub transcribed_by: Option<String>,
    pub tags: Vec<String>,
    pub solver: Option<Solver>,
    pub moves: Vec<RecordMove>,
}

A complete MSR record: the move list plus self-describing metadata.

Only version, variant and moves are essential; everything else is optional provenance, omitted when empty. Unknown fields are ignored on read, so the format is forward-compatible.

Fields

version: String

Format version, major.minor (e.g. "0.1"). A bare integer (legacy pre-0.1 files wrote 1) is accepted on read as its decimal string.

producer: Option<String>

Program that wrote the file, e.g. "morpion-solitaire/0.1.0".

variant: Variant

Game variant.

score: usize

Number of moves (equals moves.len(); stored for readability).

available_moves: Option<usize>

Legal moves still available at the final position (0 ⇔ terminal).

terminal: Option<bool>

Whether the final position is terminal (no legal move remains).

bbox: Option<[i16; 4]>

Bounding box of all placed points: [min_x, min_y, max_x, max_y].

saved_at: Option<String>

Save time as an ISO-8601 UTC string (e.g. "2026-06-14T10:30:00Z").

description: Option<String>

Free-text human description.

author: Option<String>

Who produced or owns the game (person, team, handle).

source: Option<String>

Where the record originally came from: a provenance URL or citation (e.g. the original record site, or the Pentasol file it was imported from).

transcribed_by: Option<String>

Who transcribed the game into MSR form (curator/project), as distinct from source (where the game itself originates) and author (who set the record). E.g. "morpion-solitaire.io".

tags: Vec<String>

Free-form labels (e.g. "world-record", "candidate", "verified").

solver: Option<Solver>

Machine-search provenance, present only when a solver produced the game. Absent for human / hand-played / transcribed records.

moves: Vec<RecordMove>

The moves, in play order.

Implementations

impl Record

pub fn new(variant: Variant, moves: Vec<RecordMove>) -> Record

A minimal record for variant and moves (version 1, score set, metadata empty). Fill the public metadata fields as needed.

Trait Implementations

impl Clone for Record

fn clone(&self) -> Record

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Record

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Record

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Record

fn eq(&self, other: &Record) -> 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 Record

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 Record