我想知道是否有办法在宏中获取结构的字段名称.请考虑以下示例:
struct S {
a: String,
b: String,
}
和宏__CODE__,这样称为:
my_macro!(S);
现在我想访问结构的字段名称,不知何故这样:
macro_rules! my_macro {
($t:ty) => {{
let field_names = get_field_names($t);
// do something with field_names
}};
}
我是Rust和宏的新手,所以也许我错过了一些明显的东西.
Chr*_*gan 19
在解析期间,宏或多或少地扩展; 它无法访问AST或类似的东西 - 它可以访问的是你传递给它的东西,my_macro!(S)纯粹是应该有一个名为的类型S.
如果您将结构定义为宏的一部分,那么您可以了解字段:
macro_rules! my_macro {
(struct $name:ident {
$($field_name:ident: $field_type:ty,)*
}) => {
struct $name {
$($field_name: $field_type,)*
}
impl $name {
// This is purely an example—not a good one.
fn get_field_names() -> Vec<&'static str> {
vec![$(stringify!($field_name)),*]
}
}
}
}
my_macro! {
struct S {
a: String,
b: String,
}
}
// S::get_field_names() == vec!["a", "b"]
......但这虽然可能有用,但往往是一件可疑的事情.
这是另一种不需要编写宏的可能性（但是，字段名称将在运行时解析）：
extern crate rustc_serialize;
use rustc_serialize::json::{Encoder, Json};
use rustc_serialize::json::Json::Object;
use rustc_serialize::Encodable;
#[derive(Default, RustcEncodable)]
struct S {
a: String,
b: String,
}
fn main() {
let mut json = "".to_owned();
{
let mut encoder = Encoder::new(&mut json);
S::default().encode(&mut encoder).unwrap();
}
let json = Json::from_str(&json).unwrap();
if let Object(object) = json {
let field_names: Vec<_> = object.keys().collect();
println!("{:?}", field_names);
}
}
（此解决方案需要rustc-serialize板条箱）
添加derive(Default)是为了避免必须根据需要手动创建结构（但仍会创建结构）。
该解决方案的工作原理是将结构编码为StringJSON 格式，然后将其解码为Json. 从Json对象中，我们可以提取字段名称（如果它是Object变体）。
一种可能更有效的方法是编写自己的编码器：
struct FieldNames {
names: Vec<String>,
}
impl FieldNames {
fn new() -> FieldNames {
FieldNames {
names: vec![],
}
}
}
struct FieldsEncoder<'a> {
fields: &'a mut FieldNames,
}
impl<'a> FieldsEncoder<'a> {
fn new(fields: &mut FieldNames) -> FieldsEncoder {
FieldsEncoder {
fields: fields,
}
}
}
type EncoderError = ();
impl<'a> Encoder for FieldsEncoder<'a> {
fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> {
f(self)
}
fn emit_struct_field<F>(&mut self, f_name: &str, _f_idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> {
self.fields.names.push(f_name.to_owned());
Ok(())
}
type Error = EncoderError;
fn emit_nil(&mut self) -> Result<(), Self::Error> { Err(()) }
fn emit_usize(&mut self, _v: usize) -> Result<(), Self::Error> { Err(()) }
fn emit_u64(&mut self, _v: u64) -> Result<(), Self::Error> { Err(()) }
fn emit_u32(&mut self, _v: u32) -> Result<(), Self::Error> { Err(()) }
fn emit_u16(&mut self, _v: u16) -> Result<(), Self::Error> { Err(()) }
fn emit_u8(&mut self, _v: u8) -> Result<(), Self::Error> { Err(()) }
fn emit_isize(&mut self, _v: isize) -> Result<(), Self::Error> { Err(()) }
fn emit_i64(&mut self, _v: i64) -> Result<(), Self::Error> { Err(()) }
fn emit_i32(&mut self, _v: i32) -> Result<(), Self::Error> { Err(()) }
fn emit_i16(&mut self, _v: i16) -> Result<(), Self::Error> { Err(()) }
fn emit_i8(&mut self, _v: i8) -> Result<(), Self::Error> { Err(()) }
fn emit_bool(&mut self, _v: bool) -> Result<(), Self::Error> { Err(()) }
fn emit_f64(&mut self, _v: f64) -> Result<(), Self::Error> { Err(()) }
fn emit_f32(&mut self, _v: f32) -> Result<(), Self::Error> { Err(()) }
fn emit_char(&mut self, _v: char) -> Result<(), Self::Error> { Err(()) }
fn emit_str(&mut self, _v: &str) -> Result<(), Self::Error> { Err(()) }
fn emit_enum<F>(&mut self, _name: &str, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_enum_variant<F>(&mut self, _v_name: &str, _v_id: usize, _len: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_enum_struct_variant<F>(&mut self, _v_name: &str, _v_id: usize, _len: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_enum_struct_variant_field<F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_tuple<F>(&mut self, _len: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_tuple_arg<F>(&mut self, _idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_tuple_struct<F>(&mut self, _name: &str, _len: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_tuple_struct_arg<F>(&mut self, _f_idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_option<F>(&mut self, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_option_none(&mut self) -> Result<(), Self::Error> { Err(()) }
fn emit_option_some<F>(&mut self, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_seq<F>(&mut self, _len: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_seq_elt<F>(&mut self, _idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_map<F>(&mut self, _len: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_map_elt_key<F>(&mut self, _idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
fn emit_map_elt_val<F>(&mut self, _idx: usize, _f: F) -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error> { Err(()) }
}
可以这样使用：
fn main() {
let mut fields = FieldNames::new();
{
let mut encoder = FieldsEncoder::new(&mut fields);
S::default().encode(&mut encoder).unwrap();
}
println!("{:?}", fields.names);
}
我想做同样的事情：访问结构的字段名称。但更复杂的是，该结构已经使用了样式宏，这与解决方案#[derive()]不兼容。由于我预计我的用例相当常见，因此这里快速写下我的解决方案。macro_rules!
我的最终目标是编写与crateCSV对应的标题行，即使没有写入记录（写入记录通常是通过 完成的，但我们有时会过滤所有记录，并且仍然希望有一个有效的空文件作为输出）。这个确切的问题也在另一个 SO 问题中得到了阐述，并且仅使用板条箱是不可能的，这是一个已知且当前未解决的问题。struct Recordcsvserialize()CSVcsv
对于结构体上宏的额外复杂性，我的解决方案#[derive()]是使用crate#[derive(FieldNamesAsArray)]定义的宏struct-field-names-as-array。
您需要在以下位置定义依赖关系Cargo.toml：
[dependencies]
struct-field-names-as-array = "0.1"
然后，您可以简单地使用相应的派生宏注释模块struct Record中的something.rs，并使用生成的常量Record::FIELD_NAMES_AS_ARRAY进行标头写入：
// csv-specific imports
use csv::WriterBuilder;
use serde::Serialize;
// import for getting the field names array
use struct_field_names_as_array::FieldNamesAsArray;
// Serialize from serde, to write `Record`s systematically
// FieldNamesAsArray to get the field names
#[derive(Serialize,FieldNamesAsArray)]
struct Record {
field_1: String,
field_2: u64,
}
// ensure that serializing records does not write a header with
// the `.has_headers(false)`
let mut csv_writer = csv::WriterBuilder::new()
.has_headers(false)
.from_path("foo.csv")?;
// Manually write out the header.
csv_writer.write_record(Record::FIELD_NAMES_AS_ARRAY)?;
// `serialize()` records later, if some condition is met.
// But we also have a correct header if this condition is never met.
if some_condition {
csv_writer.serialize(Recor {
field_1: "some_string",
field_2: 71028743,
})?;
}