How to deserialize &str struct field from JSON in Rust

Question

I'm deserializing a struct from JSON:

fn main() {
  let raw_json = r#"{"error": {"msg": "I am an error message"}}"#;
  let error: Error = json::decode(raw_json).unwrap();

}

struct Error {
  message: &'static str
}

impl<D: Decoder<E>, E> Decodable<D, E> for Error {
  fn decode(d: &mut D) -> Result<Error, E> {
    d.read_struct("error", 1, |d| {
      Ok(Error{
        message: try!(d.read_struct_field("msg", 0u, |d| Decodable::decode(d)))
      })
    })
  }
}

But getting this error:

failed to find an implementation of trait serialize::serialize::Decodable<D,E> for &'static str

Adding lifetime to message does not help. Turns out there is no implementation of Decodable trait for &str, but only for String

How do I deserialize my JSON into &str struct field?

A.B. · Accepted Answer · 2014-08-14 09:20:04Z

References can't be serialized or deserialized. A different approach is needed.

Your Error struct contains a &'static str. This means you could also represent errors in the form of an enum, which can be serialized. Then you could implement Show for Error.

extern crate serialize;
use serialize::{Decodable, Encodable};
use std::fmt;

#[deriving(Encodable, Decodable)]
enum Error {
    Foo,
    Bar
}

impl fmt::Show for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Foo => write!(f, "Foo happened"),
            Bar => write!(f, "Bar happened"),
        }
    }
}

The question is whether this is actually what you wanted. If you want the ability to represent an arbitrary error message (rather than a specific error type) then you'll have to use String.

extern crate serialize;
use serialize::{Decodable, Encodable};

#[deriving(Encodable, Decodable)]
struct Error {
    msg: String
}

Chris Morgan · Accepted Answer · 2014-08-14 08:55:37Z

2

For &'static str, you must have a string literal, a string that lasts for lifetime of the entire process (a.k.a. forever). This evidently can’t be achieved.

For &'a str in general, something else must be owning the bytes—it is a reference to some of the contents of a String, in general (it might also be Vec<Ascii> or possibly another similar UTF-8 string type outside the standard library). This is not the way in which the serialization works—there is not necessarily a value stored anywhere permanent, so it can’t produce references. This is why it’s only implemented for String: you simply cannot have it for &str.

answered Aug 14, 2014 at 8:55

Chris Morgan

91.6k28 gold badges217 silver badges220 bronze badges

1 Comment

Valentin V Over a year ago

Thanks for this. My all problems stem from lack of understanding between str and String. Now finally I think I get it. String is the place where the actual string is stored, while &str is just a view on it. With literals, &str is just a view on a literal. So we can't deserialize the view, we can only do it for the real storage.

Collectives™ on Stack Overflow

How to deserialize &str struct field from JSON in Rust

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related