1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use super::binary::{Binary, OwnedBinary};
use {Decoder, Encoder, Env, Error, NifResult, Term};

impl<'a> Decoder<'a> for String {
    fn decode(term: Term<'a>) -> NifResult<Self> {
        let string: &str = try!(Decoder::decode(term));
        Ok(string.to_string())
    }
}
impl<'a> Decoder<'a> for &'a str {
    fn decode(term: Term<'a>) -> NifResult<Self> {
        let binary = try!(Binary::from_term(term));
        match ::std::str::from_utf8(binary.as_slice()) {
            Ok(string) => Ok(string),
            Err(_) => Err(Error::BadArg),
        }
    }
}

use std::io::Write;

impl<'a> Encoder for &'a str {
    fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
        (*self).encode(env)
    }
}

impl Encoder for str {
    fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
        let str_len = self.len();
        let mut bin = match OwnedBinary::new(str_len) {
            Some(bin) => bin,
            None => panic!("binary term allocation fail"),
        };
        bin.as_mut_slice()
            .write(self.as_bytes())
            .expect("memory copy of string failed");
        bin.release(env).to_term(env)
    }
}

impl Encoder for String {
    fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
        self.as_str().encode(env)
    }
}