bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Drop the '2' suffix from logging macros

Browse source 
Who doesn't like a massive renaming?
This commit is contained in:
Alex Crichton 2013-10-21 13:08:31 -07:00
parent 15a6bdebab
commit daf5f5a4d1
726 changed files with 3060 additions and 3060 deletions
Download patch file Download diff file Expand all files Collapse all files

66
src/libextra/json.rs
View file

@ -880,10 +880,10 @@ pub fn Decoder(json: Json) -> Decoder {
impl serialize::Decoder for Decoder {
fn read_nil(&mut self) -> () {
debug2!("read_nil");
debug!("read_nil");
match self.stack.pop() {
Null => (),
value => fail2!("not a null: {:?}", value)
value => fail!("not a null: {:?}", value)
}
}
@ -900,18 +900,18 @@ impl serialize::Decoder for Decoder {
fn read_int(&mut self) -> int { self.read_f64() as int }
fn read_bool(&mut self) -> bool {
debug2!("read_bool");
debug!("read_bool");
match self.stack.pop() {
Boolean(b) => b,
value => fail2!("not a boolean: {:?}", value)
value => fail!("not a boolean: {:?}", value)
}
}
fn read_f64(&mut self) -> f64 {
debug2!("read_f64");
debug!("read_f64");
match self.stack.pop() {
Number(f) => f,
value => fail2!("not a number: {:?}", value)
value => fail!("not a number: {:?}", value)
}
}
fn read_f32(&mut self) -> f32 { self.read_f64() as f32 }
@ -921,20 +921,20 @@ impl serialize::Decoder for Decoder {
let mut v = ~[];
let s = self.read_str();
for c in s.iter() { v.push(c) }
if v.len() != 1 { fail2!("string must have one character") }
if v.len() != 1 { fail!("string must have one character") }
v[0]
}
fn read_str(&mut self) -> ~str {
debug2!("read_str");
debug!("read_str");
match self.stack.pop() {
String(s) => s,
json => fail2!("not a string: {:?}", json)
json => fail!("not a string: {:?}", json)
}
}
fn read_enum<T>(&mut self, name: &str, f: &fn(&mut Decoder) -> T) -> T {
debug2!("read_enum({})", name);
debug!("read_enum({})", name);
f(self)
}
@ -942,13 +942,13 @@ impl serialize::Decoder for Decoder {
names: &[&str],
f: &fn(&mut Decoder, uint) -> T)
-> T {
debug2!("read_enum_variant(names={:?})", names);
debug!("read_enum_variant(names={:?})", names);
let name = match self.stack.pop() {
String(s) => s,
Object(o) => {
let n = match o.find(&~"variant").expect("invalidly encoded json") {
&String(ref s) => s.clone(),
_ => fail2!("invalidly encoded json"),
_ => fail!("invalidly encoded json"),
};
match o.find(&~"fields").expect("invalidly encoded json") {
&List(ref l) => {
@ -956,15 +956,15 @@ impl serialize::Decoder for Decoder {
self.stack.push(field.clone());
}
},
_ => fail2!("invalidly encoded json")
_ => fail!("invalidly encoded json")
}
n
}
ref json => fail2!("invalid variant: {:?}", *json),
ref json => fail!("invalid variant: {:?}", *json),
};
let idx = match names.iter().position(|n| str::eq_slice(*n, name)) {
Some(idx) => idx,
None => fail2!("Unknown variant name: {}", name),
None => fail!("Unknown variant name: {}", name),
};
f(self, idx)
}
@ -973,7 +973,7 @@ impl serialize::Decoder for Decoder {
idx: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_enum_variant_arg(idx={})", idx);
debug!("read_enum_variant_arg(idx={})", idx);
f(self)
}
@ -981,7 +981,7 @@ impl serialize::Decoder for Decoder {
names: &[&str],
f: &fn(&mut Decoder, uint) -> T)
-> T {
debug2!("read_enum_struct_variant(names={:?})", names);
debug!("read_enum_struct_variant(names={:?})", names);
self.read_enum_variant(names, f)
}
@ -991,7 +991,7 @@ impl serialize::Decoder for Decoder {
idx: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_enum_struct_variant_field(name={}, idx={})", name, idx);
debug!("read_enum_struct_variant_field(name={}, idx={})", name, idx);
self.read_enum_variant_arg(idx, f)
}
@ -1000,7 +1000,7 @@ impl serialize::Decoder for Decoder {
len: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_struct(name={}, len={})", name, len);
debug!("read_struct(name={}, len={})", name, len);
let value = f(self);
self.stack.pop();
value
@ -1011,12 +1011,12 @@ impl serialize::Decoder for Decoder {
idx: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_struct_field(name={}, idx={})", name, idx);
debug!("read_struct_field(name={}, idx={})", name, idx);
match self.stack.pop() {
Object(obj) => {
let mut obj = obj;
let value = match obj.pop(&name.to_owned()) {
None => fail2!("no such field: {}", name),
None => fail!("no such field: {}", name),
Some(json) => {
self.stack.push(json);
f(self)
@ -1025,12 +1025,12 @@ impl serialize::Decoder for Decoder {
self.stack.push(Object(obj));
value
}
value => fail2!("not an object: {:?}", value)
value => fail!("not an object: {:?}", value)
}
}
fn read_tuple<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
debug2!("read_tuple()");
debug!("read_tuple()");
self.read_seq(f)
}
@ -1038,7 +1038,7 @@ impl serialize::Decoder for Decoder {
idx: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_tuple_arg(idx={})", idx);
debug!("read_tuple_arg(idx={})", idx);
self.read_seq_elt(idx, f)
}
@ -1046,7 +1046,7 @@ impl serialize::Decoder for Decoder {
name: &str,
f: &fn(&mut Decoder, uint) -> T)
-> T {
debug2!("read_tuple_struct(name={})", name);
debug!("read_tuple_struct(name={})", name);
self.read_tuple(f)
}
@ -1054,7 +1054,7 @@ impl serialize::Decoder for Decoder {
idx: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_tuple_struct_arg(idx={})", idx);
debug!("read_tuple_struct_arg(idx={})", idx);
self.read_tuple_arg(idx, f)
}
@ -1066,7 +1066,7 @@ impl serialize::Decoder for Decoder {
}
fn read_seq<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
debug2!("read_seq()");
debug!("read_seq()");
let len = match self.stack.pop() {
List(list) => {
let len = list.len();
@ -1075,18 +1075,18 @@ impl serialize::Decoder for Decoder {
}
len
}
_ => fail2!("not a list"),
_ => fail!("not a list"),
};
f(self, len)
}
fn read_seq_elt<T>(&mut self, idx: uint, f: &fn(&mut Decoder) -> T) -> T {
debug2!("read_seq_elt(idx={})", idx);
debug!("read_seq_elt(idx={})", idx);
f(self)
}
fn read_map<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
debug2!("read_map()");
debug!("read_map()");
let len = match self.stack.pop() {
Object(obj) => {
let len = obj.len();
@ -1096,7 +1096,7 @@ impl serialize::Decoder for Decoder {
}
len
}
json => fail2!("not an object: {:?}", json),
json => fail!("not an object: {:?}", json),
};
f(self, len)
}
@ -1105,13 +1105,13 @@ impl serialize::Decoder for Decoder {
idx: uint,
f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_map_elt_key(idx={})", idx);
debug!("read_map_elt_key(idx={})", idx);
f(self)
}
fn read_map_elt_val<T>(&mut self, idx: uint, f: &fn(&mut Decoder) -> T)
-> T {
debug2!("read_map_elt_val(idx={})", idx);
debug!("read_map_elt_val(idx={})", idx);
f(self)
}
}