用法

要将 Rust 结构体（或映射）序列化和反序列化为 Namelist 组，可以使用 group_from_str 和 group_to_string 方法

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Particle {
    timestep: i32,
    mass: f32,
    position: [f32; 3],
    velocity: [f32; 3]
}

fn main() -> Result<(), nml::NamelistError> {
    let p = Particle {
        timestep: 0,
        mass: 1.0,
        position: [0.0, 0.0, 0.0],
        velocity: [-1.0, 0.0, 0.0]
    };

    let serialized = nml::group_to_string(p)?;
    let deserialized = nml::group_from_str(&serialized)?;

    assert_eq!(p, deserialized);
    Ok(())
}

要从单个输入中反序列化多个 Namelist 组（具有相同或不同的组名）到 Rust 结构体或映射，可以使用 NamelistInput 类型

use serde::Deserialize;
#[derive(Deserialize, Debug)]
struct Simulation {
    start_time: i32,
    timesteps: i32
}

#[derive(Deserialize, Debug)]
struct Particle {
   index: i32,
   position: [f32; 3],
   velocity: [f32; 3]
}

fn main() -> Result<(), nml::NamelistError>{
   let s = r#"
       &simulation
         start_time: 0,
         timesteps: 10,
       /
       &particle
        index = 0,
        position = 0.0, 0.0, 0.0,
        velocity = 1.0, 0.0, 0.0,
       /
       &particle
        index = 1,
        position = 1.0, 0.0, 0.0,
        velocity = -1.0, 0.0, 0.0,
       /"#;

   let input = NamelistInput::try_from_str(s)?;
   let mut simulation = None;
   let mut particles = Vec::new();

   for group in &input {
       if group.name() == "particle" {
           let particle = Particle::deserialize(group)?;
           particles.push(particle);
       } else if group.name() == "simulation" {
           simulation = Some(Simulation::deserialize(group)?);
       }
   }
   Ok(())
}

如你所见，NamelistInput 类型可以解析多个 namelist 组，并且可以被转换为迭代器，每次产生一个 GroupRefDeserializer 实例，对应输入中的每个 namelist 组。此类型可用于将 namelist 组反序列化为 Rust 结构体或映射。

支持的 Namelist 语法

支持

• 所有基本数据类型，整数，逻辑，字符串，实数
• 数组：使用下标分配序列和单个元素
• 派生类型

不支持:

• 涉及切片操作符 : 的任何内容，例如：var(1:3) = 1, 2, 3,
• 将序列赋值给下标变量，即 var(1) = 1, 2, 3