src/libstd/prettyprint.rs

   1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #[forbid(deprecated_mode)];
  12
  13 use serialize;
  14
  15 use core::io::Writer;
  16 use core::io::WriterUtil;
  17 use core::io;
  18
  19 pub struct Serializer {
  20     wr: io::Writer,
  21 }
  22
  23 pub fn Serializer(wr: io::Writer) -> Serializer {
  24     Serializer { wr: wr }
  25 }
  26
  27 pub impl Serializer: serialize::Encoder {
  28     fn emit_nil(&self) {
  29         self.wr.write_str(~"()")
  30     }
  31
  32     fn emit_uint(&self, v: uint) {
  33         self.wr.write_str(fmt!("%?u", v));
  34     }
  35
  36     fn emit_u64(&self, v: u64) {
  37         self.wr.write_str(fmt!("%?_u64", v));
  38     }
  39
  40     fn emit_u32(&self, v: u32) {
  41         self.wr.write_str(fmt!("%?_u32", v));
  42     }
  43
  44     fn emit_u16(&self, v: u16) {
  45         self.wr.write_str(fmt!("%?_u16", v));
  46     }
  47
  48     fn emit_u8(&self, v: u8) {
  49         self.wr.write_str(fmt!("%?_u8", v));
  50     }
  51
  52     fn emit_int(&self, v: int) {
  53         self.wr.write_str(fmt!("%?", v));
  54     }
  55
  56     fn emit_i64(&self, v: i64) {
  57         self.wr.write_str(fmt!("%?_i64", v));
  58     }
  59
  60     fn emit_i32(&self, v: i32) {
  61         self.wr.write_str(fmt!("%?_i32", v));
  62     }
  63
  64     fn emit_i16(&self, v: i16) {
  65         self.wr.write_str(fmt!("%?_i16", v));
  66     }
  67
  68     fn emit_i8(&self, v: i8) {
  69         self.wr.write_str(fmt!("%?_i8", v));
  70     }
  71
  72     fn emit_bool(&self, v: bool) {
  73         self.wr.write_str(fmt!("%b", v));
  74     }
  75
  76     fn emit_float(&self, v: float) {
  77         self.wr.write_str(fmt!("%?_f", v));
  78     }
  79
  80     fn emit_f64(&self, v: f64) {
  81         self.wr.write_str(fmt!("%?_f64", v));
  82     }
  83
  84     fn emit_f32(&self, v: f32) {
  85         self.wr.write_str(fmt!("%?_f32", v));
  86     }
  87
  88     fn emit_char(&self, v: char) {
  89         self.wr.write_str(fmt!("%?", v));
  90     }
  91
  92     fn emit_borrowed_str(&self, v: &str) {
  93         self.wr.write_str(fmt!("&%?", v));
  94     }
  95
  96     fn emit_owned_str(&self, v: &str) {
  97         self.wr.write_str(fmt!("~%?", v));
  98     }
  99
 100     fn emit_managed_str(&self, v: &str) {
 101         self.wr.write_str(fmt!("@%?", v));
 102     }
 103
 104     fn emit_borrowed(&self, f: fn()) {
 105         self.wr.write_str(~"&");
 106         f();
 107     }
 108
 109     fn emit_owned(&self, f: fn()) {
 110         self.wr.write_str(~"~");
 111         f();
 112     }
 113
 114     fn emit_managed(&self, f: fn()) {
 115         self.wr.write_str(~"@");
 116         f();
 117     }
 118
 119     fn emit_enum(&self, _name: &str, f: fn()) {
 120         f();
 121     }
 122
 123     fn emit_enum_variant(&self, v_name: &str, _v_id: uint, sz: uint,
 124                          f: fn()) {
 125         self.wr.write_str(v_name);
 126         if sz > 0u { self.wr.write_str(~"("); }
 127         f();
 128         if sz > 0u { self.wr.write_str(~")"); }
 129     }
 130
 131     fn emit_enum_variant_arg(&self, idx: uint, f: fn()) {
 132         if idx > 0u { self.wr.write_str(~", "); }
 133         f();
 134     }
 135
 136     fn emit_borrowed_vec(&self, _len: uint, f: fn()) {
 137         self.wr.write_str(~"&[");
 138         f();
 139         self.wr.write_str(~"]");
 140     }
 141
 142     fn emit_owned_vec(&self, _len: uint, f: fn()) {
 143         self.wr.write_str(~"~[");
 144         f();
 145         self.wr.write_str(~"]");
 146     }
 147
 148     fn emit_managed_vec(&self, _len: uint, f: fn()) {
 149         self.wr.write_str(~"@[");
 150         f();
 151         self.wr.write_str(~"]");
 152     }
 153
 154     fn emit_vec_elt(&self, idx: uint, f: fn()) {
 155         if idx > 0u { self.wr.write_str(~", "); }
 156         f();
 157     }
 158
 159     fn emit_rec(&self, f: fn()) {
 160         self.wr.write_str(~"{");
 161         f();
 162         self.wr.write_str(~"}");
 163     }
 164
 165     fn emit_struct(&self, name: &str, _len: uint, f: fn()) {
 166         self.wr.write_str(fmt!("%s {", name));
 167         f();
 168         self.wr.write_str(~"}");
 169     }
 170
 171     fn emit_field(&self, name: &str, idx: uint, f: fn()) {
 172         if idx > 0u { self.wr.write_str(~", "); }
 173         self.wr.write_str(name);
 174         self.wr.write_str(~": ");
 175         f();
 176     }
 177
 178     fn emit_tup(&self, _len: uint, f: fn()) {
 179         self.wr.write_str(~"(");
 180         f();
 181         self.wr.write_str(~")");
 182     }
 183
 184     fn emit_tup_elt(&self, idx: uint, f: fn()) {
 185         if idx > 0u { self.wr.write_str(~", "); }
 186         f();
 187     }
 188 }