Implementation of ::std::cmp::Eq for WorkKey

Automatically derived.

Method eq

fn eq(&self, __arg_0: &WorkKey) -> ::bool

Method ne

fn ne(&self, __arg_0: &WorkKey) -> ::bool

Implementation of ::extra::serialize::Encodable<__E> for WorkKey where <__E: ::extra::serialize::Encoder>

Automatically derived.

Method encode

fn encode(&self, __arg_0: &mut __E)

Implementation of ::extra::serialize::Decodable<__D> for WorkKey where <__D: ::extra::serialize::Decoder>

Automatically derived.

Method decode

fn decode(__arg_0: &mut __D) -> WorkKey

Implementation of to_bytes::IterBytes for WorkKey

Method iter_bytes

fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool

Implementation of cmp::Ord for WorkKey

Method lt

fn lt(&self, other: &WorkKey) -> bool

Method le

fn le(&self, other: &WorkKey) -> bool

Method ge

fn ge(&self, other: &WorkKey) -> bool

Method gt

fn gt(&self, other: &WorkKey) -> bool

Implementation for WorkKey

Method new

fn new(kind: &str, name: &str) -> WorkKey

Implementation of Encodable<S> for WorkMap where <S: Encoder>

Method encode

fn encode(&self, s: &mut S)

Implementation of Decodable<D> for WorkMap where <D: Decoder>

Method decode

fn decode(d: &mut D) -> WorkMap

Implementation for Database

Method prepare

fn prepare(&mut self, fn_name: &str, declared_inputs: &WorkMap) ->
 Option<(WorkMap, WorkMap, ~str)>

Method cache

fn cache(&mut self, fn_name: &str, declared_inputs: &WorkMap,
         discovered_inputs: &WorkMap, discovered_outputs: &WorkMap,
         result: &str)

Implementation for Logger

Method info

fn info(&self, i: &str)

Implementation for Context

Method new

fn new(db: @mut Database, lg: @mut Logger, cfg: @json::Object) -> Context

Method prep

fn prep<T: Send + Encodable<json::Encoder> +
        Decodable<json::Decoder>>(@self, fn_name: &str,
                                  blk: &fn(@mut Prep) -> Work<T>) -> Work<T>

Implementation of TPrep for Prep

Method declare_input

fn declare_input(&mut self, kind: &str, name: &str, val: &str)

Method is_fresh

fn is_fresh(&self, cat: &str, kind: &str, name: &str, val: &str) -> bool

Method all_fresh

fn all_fresh(&self, cat: &str, map: &WorkMap) -> bool

Method exec

fn exec<T: Send + Encodable<json::Encoder> +
        Decodable<json::Decoder>>(&self, blk: ~fn(&Exec) -> T) -> Work<T>

Implementation for Work<T> where <T: Send + Encodable<json::Encoder> + Decodable<json::Decoder>>

Method new

fn new(p: @mut Prep, e: Either<T, PortOne<(Exec, T)>>) -> Work<T>