Several managed closures with shared state? - rust

Question

I am trying to implement a Rust wrapper for Expat XML parser. I wrapped the start_element, end_element callbacks and they work fine in simple cases (e.g. just counting XML elements) as follows:
struct Expat {
parser: expat::XML_Parser
}
type StartHandler = #fn(tag: &str, attrs: &[~str]);
type EndHandler = #fn(tag: &str);
type TextHandler = #fn(text: &str);
struct Handlers {
start_handler: StartHandler,
end_handler: EndHandler,
text_handler: TextHandler
}
impl Expat {
pub fn handlers(&self, start_handler: StartHandler, end_handler: EndHandler, text_handler: TextHandler) {
let handlers = #Handlers {
start_handler: start_handler,
end_handler: end_handler,
text_handler: text_handler
};
// How to do this properly?
unsafe { cast::bump_box_refcount(handlers) };
expat::XML_SetUserData(self.parser, unsafe { cast::transmute(&*handlers) });
}
I can pass simple managed closures to handlers() and have them update #mut uint values.
Now I want to maintain the current XPath across callbacks and am having problems:
let mut xpath: ~[~str] = ~[];
let xpath_start_handler: #fn(&str, &[~str]) = |tag: &str, _attrs: &[~str]| {
vec::push(&xpath, tag.to_owned());
println(fmt!(" start: %?", xpath));
};
let xpath_end_handler: #fn(&str) = |tag: &str| {
println(fmt!(" end: %?", xpath));
let top = vec::pop(&xpath);
if top != tag.to_owned() {
fail!(fmt!("expected end tag: %s, received end tag: %s", top, tag));
}
};
let xpath_text_handler: #fn(&str) = |_text: &str| {
};
expat.handlers(xpath_start_handler, xpath_end_handler, xpath_text_handler);
The compiler says that the unique vector xpath was moved into the xpath_start_handler closure and cannot be accessed in xpath_end_closure.
So my question is what is the best way to maintain mutable state across many managed closures?

Answer 1

Shared boxes should be managed, not unique:
let state: #mut ~[~str] = #mut ~[];
let push: #fn(~str) = |x| {
vec::push(state, x);
};
let pop: #fn() -> ~str = || {
vec::pop(state)
};
let count: #fn() -> uint = || {
(&*state).len()
};
push(~"ho");
push(~"hey");
println(fmt!("%?", count()));
println(pop());
println(pop());
println(fmt!("%?", count()));
Also, mutable unique boxes work a bit differently than mutable managed boxes.