pzol

fn compare_ci(x: &str, y: &str) -> bool {
  if x.char_len() != y.char_len() {
    return false;
  }

  let mut it = x.chars().zip(y.chars());
  it.all(|(x,y)|
    unsafe {
      x.to_ascii_nocheck().to_lower() == y.to_ascii_nocheck().to_lower()
    }

pzol

#[ crate_id = "vmod_rpm#0.1" ];
// #[ crate_type = "lib" ];
#[ no_std ];
// #[ allow(ctypes) ];

// #[no_mangle]
// pub extern fn add(lhs: uint, rhs: uint) -> uint {
//   lhs + rhs
// }

pzol

use std::sync::atomics::{ AtomicUint, INIT_ATOMIC_UINT, Ordering, AcqRel };

static counter: AtomicUint = INIT_ATOMIC_UINT;

fn call() -> uint {
  let current = counter.fetch_add(1, AcqRel);
  current.clone()
}

pzol

#[ crate_id = "vmod_rpm#0.1" ];
#[ crate_type = "dylib" ];
// #[ no_std ];
#[ allow(ctypes) ];

extern mod extra;

use std::str;
use std::sync::atomics;
use std::sync::atomics::{ AtomicUint, AcqRel };

pzol

use std::hashmap::HashMap;

#[test]
fn test(){

  let mut omap: Option<HashMap<~str, uint>> = None;
  omap = Some(HashMap::new());
  let must_insert = false;

  {

pzol

use std::hashmap::HashMap;

#[test]
fn test_mangle(){
  let mut map = HashMap::<~str, uint>::new();
  assert!(!map.contains_key(&~"foo"));

  map.mangle(~"foo", 1,
             |_k, a| a + 10,
             |_k, v, a| *v -= 2

pzol

#[test]
fn test_iter(){
  let mut map = HashMap::<~str, uint>::new();
  map.insert(~"foo", 1);
  map.insert(~"bar", 2);

  let mut numbers = ~[];
  for (_k,v) in map.iter() {
    numbers.push(v.clone());
  }

pzol

trait A {}

trait B {}


fn foo<t: A>() {
}

fn foo<t: B>() {

pzol

#[deriving(Eq)]
struct ParamsBuilder {
    foo: uint,
    bar: ~str,
    baz: uint,
    run: bool
}

impl ParamsBuilder {

pzol

struct Foo<'a> {
  name: &'a str
}

impl<'a> Foo<'a> {
  fn name(&'a mut self, s: &'a str) -> &'a mut Foo<'a> {
    self.name = s;
    self
  }