Struct toml::Encoder

pub struct Encoder {
    pub toml: TomlTable,
    // 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: TomlTable

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>