Struct toml::Encoder [−] [src]

pub struct Encoder {
    pub toml: Table,
    // some fields omitted
}

A structure to transform Rust values into TOML values.

This encoder implements the serialization Encoder interface, allowing Encodable rust types to be fed into the encoder. The output of this encoder is a TOML Table structure. The resulting TOML can be stringified if necessary.

Example

extern crate rustc_serialize;
extern crate toml;

use toml::{Encoder, Value};
use rustc_serialize::Encodable;

#[derive(RustcEncodable)]
struct MyStruct { foo: isize, bar: String }
let my_struct = MyStruct { foo: 4, bar: "hello!".to_string() };

let mut e = Encoder::new();
my_struct.encode(&mut e).unwrap();

assert_eq!(e.toml.get(&"foo".to_string()), Some(&Value::Integer(4)))

Fields

toml

Output TOML that is emitted. The current version of this encoder forces the top-level representation of a structure to be a table.

This field can be used to extract the return value after feeding a value into this Encoder.

Methods

`impl Encoder`

`fn new() -> Encoder`

Constructs a new encoder which will emit to the given output stream.

Trait Implementations

`impl Encoder for Encoder`

`type Error = Error`

`fn emit_nil(&mut self) -> Result<(), Error>`

`fn emit_usize(&mut self, v: usize) -> Result<(), Error>`

`fn emit_u8(&mut self, v: u8) -> Result<(), Error>`

`fn emit_u16(&mut self, v: u16) -> Result<(), Error>`

`fn emit_u32(&mut self, v: u32) -> Result<(), Error>`

`fn emit_u64(&mut self, v: u64) -> Result<(), Error>`

`fn emit_isize(&mut self, v: isize) -> Result<(), Error>`

`fn emit_i8(&mut self, v: i8) -> Result<(), Error>`

`fn emit_i16(&mut self, v: i16) -> Result<(), Error>`

`fn emit_i32(&mut self, v: i32) -> Result<(), Error>`

`fn emit_i64(&mut self, v: i64) -> Result<(), Error>`

`fn emit_bool(&mut self, v: bool) -> Result<(), Error>`

`fn emit_f32(&mut self, v: f32) -> Result<(), Error>`

`fn emit_f64(&mut self, v: f64) -> Result<(), Error>`

`fn emit_char(&mut self, v: char) -> Result<(), Error>`

`fn emit_str(&mut self, v: &str) -> Result<(), Error>`

`fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_enum_variant<F>(&mut self, _v_name: &str, _v_id: usize, _len: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_enum_struct_variant<F>(&mut self, _v_name: &str, _v_id: usize, _len: usize, _f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_enum_struct_variant_field<F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_struct_field<F>(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_tuple<F>(&mut self, len: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_tuple_struct<F>(&mut self, _name: &str, _len: usize, _f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_tuple_struct_arg<F>(&mut self, _f_idx: usize, _f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_option<F>(&mut self, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_option_none(&mut self) -> Result<(), Error>`

`fn emit_option_some<F>(&mut self, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_seq<F>(&mut self, _len: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`

`fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Error> where F: FnOnce(&mut Encoder) -> Result<(), Error>`