格式化结构字段的方式与其JSON密钥的格式不同

Question

Rust的rustc-serialize包允许结构分别从RustcEncodable和RustcDecodable中分别自动序列化或反序列化为JSON。例如，下面的结构：

#[derive(RustcEncodable, RustcDecodable)] 
struct Person { 
    first_name: String, 
    last_name: String, 
    age: u8, 
} 

将表示为这个JSON：

{ 
    "first_name": "Joe", 
    "last_name": "Shmoe", 
    "age": 30 
} 

我需要反序列化使用了驼峰式大小写键一些JSON。这似乎要求struct字段的命名方式相似，这会发出编译器警告，结构字段应该是蛇形的。我可以用#[allow(non_snake_case)]来消除这个警告，但我宁愿让struct字段是蛇形的。有没有办法做到这一点，而不用手动实现JSON序列化/反序列化与ToJson/Encodable/Decodable特征？

Answer 1

不，#[derive]基础设施根本没有提供任何定制机会。

你可以，但是，知道#[derive]东西扩展做什么用rustc -Z unstable-options --pretty expanded：

#![feature(no_std)] 
#![no_std] 
#[prelude_import] 
use std::prelude::v1::*; 
#[macro_use] 
extern crate std as std; 
struct Person { 
    first_name: String, 
    last_name: String, 
    age: u8, 
} 
#[automatically_derived] 
impl ::rustc_serialize::Decodable for Person { 
    fn decode<__D: ::rustc_serialize::Decoder>(__arg_0: &mut __D) 
    -> ::std::result::Result<Person, __D::Error> { 
     __arg_0.read_struct("Person", 3usize, |_d| -> _ { 
          ::std::result::Result::Ok(Person{first_name: 
                   match _d.read_struct_field("first_name", 
                          0usize, 
                          ::rustc_serialize::Decodable::decode) 
                    { 
                    ::std::result::Result::Ok(__try_var) 
                    => 
                    __try_var, 
                    ::std::result::Result::Err(__try_var) 
                    => 
                    return ::std::result::Result::Err(__try_var), 
                   }, 
                  last_name: 
                   match _d.read_struct_field("last_name", 
                          1usize, 
                          ::rustc_serialize::Decodable::decode) 
                    { 
                    ::std::result::Result::Ok(__try_var) 
                    => 
                    __try_var, 
                    ::std::result::Result::Err(__try_var) 
                    => 
                    return ::std::result::Result::Err(__try_var), 
                   }, 
                  age: 
                   match _d.read_struct_field("age", 
                          2usize, 
                          ::rustc_serialize::Decodable::decode) 
                    { 
                    ::std::result::Result::Ok(__try_var) 
                    => 
                    __try_var, 
                    ::std::result::Result::Err(__try_var) 
                    => 
                    return ::std::result::Result::Err(__try_var), 
                   },}) }) 
    } 
} 
#[automatically_derived] 
impl ::rustc_serialize::Encodable for Person { 
    fn encode<__S: ::rustc_serialize::Encoder>(&self, __arg_0: &mut __S) 
    -> ::std::result::Result<(), __S::Error> { 
     match *self { 
      Person { 
      first_name: ref __self_0_0, 
      last_name: ref __self_0_1, 
      age: ref __self_0_2 } => 
      __arg_0.emit_struct("Person", 3usize, |_e| -> _ { 
           match _e.emit_struct_field("first_name", 
                  0usize, |_e| -> _ { 
                  (*__self_0_0).encode(_e) 
                 }) { 
            ::std::result::Result::Ok(__try_var) => 
            __try_var, 
            ::std::result::Result::Err(__try_var) => 
            return ::std::result::Result::Err(__try_var), 
           }; 
           match _e.emit_struct_field("last_name", 
                  1usize, |_e| -> _ { 
                  (*__self_0_1).encode(_e) 
                 }) { 
            ::std::result::Result::Ok(__try_var) => 
            __try_var, 
            ::std::result::Result::Err(__try_var) => 
            return ::std::result::Result::Err(__try_var), 
           }; 
           return _e.emit_struct_field("age", 2usize, 
                  |_e| -> _ { 
                  (*__self_0_2).encode(_e) 
                 }); }), 
     } 
    } 
} 

是啊，这是相当笨拙，所有展开这样的，但它可以很容易地折叠和改变，以适应：

impl Decodable for Person { 
    fn decode<D: Decoder>(decoder: &mut D) -> Result<Person, D::Error> { 
     decoder.read_struct("Person", 3, |d| Ok(Person { 
      first_name: try!(d.read_struct_field("firstName", 0, Decodable::decode)), 
      last_name: try!(d.read_struct_field("lastName", 1, Decodable::decode)), 
      age: try!(d.read_struct_field("age", 2, Decodable::decode)), 
     })) 
    } 
} 

impl Encodable for Person { 
    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { 
     s.emit_struct("Person", 3, |e| { 
      try!(e.emit_struct_field("firstName", 0, |e| self.first_name.encode(e))); 
      try!(e.emit_struct_field("lastName", 1, |e| self.last_name.encode(e))); 
      e.emit_struct_field("age", 2, |e| self.age.encode(e)) 
     }) 
    } 
}