pub const STORMSG_MAJOR: i64 = 0i64;
pub const STORMSG_MINOR: i64 = 983i64;
pub const STORSTAT_NAMELEN: i64 = 256i64;
#[derive(Debug, Eq, PartialEq)]
pub enum Bdbflush { BDBFLUSH_SUCCESS, BDBFLUSH_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum Bdbflush_e { BDBFLUSH_SUCCESS = 0isize, BDBFLUSH_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum Bdbflushop { BDBFLUSH_FULL = 1isize, BDBFLUSH_MARK = 2isize, }
#[derive(Debug, Eq, PartialEq)]
pub struct Detached {
pub err: i32,
}
#[derive(Debug, Eq, PartialEq)]
pub struct Err {
pub ecode: i32,
pub msg: String,
}
pub type Iobufaddr = Vec<u8>;
#[derive(Debug, Eq, PartialEq)]
pub struct Markchk {
pub copies: bool,
pub placement: bool,
}
#[derive(Debug, Eq, PartialEq)]
pub struct Markop {
pub op: Markop_e,
pub wave: Wave,
}
#[derive(Debug, Eq, PartialEq)]
pub enum Markop_e {
MARKOP_NOP = 0isize,
MARKOP_GET_MARK = 1isize,
MARKOP_GET_SUBGRAPH = 2isize,
MARKOP_SET_MARK = 3isize,
MARKOP_SET_MARK_GEOM = 4isize,
MARKOP_SET_MARK_OFFSET = 5isize,
MARKOP_SET_SUBGRAPH = 6isize,
MARKOP_SET_MARK_REBASE = 7isize,
MARKOP_GET_PLACEMENT = 8isize,
MARKOP_GET_OBJCOUNT = 9isize,
MARKOP_SET_OBJCOUNT = 10isize,
MARKOP_GET_BYTECOUNT = 11isize,
MARKOP_SET_BYTECOUNT = 12isize,
MARKOP_GET_SIZE = 13isize,
}
#[derive(Debug, Eq, PartialEq)]
pub enum Markres {
MARKRES_OK,
MARKRES_ERR(Box<Err>),
MARKRES_WAVE(Box<Wave>),
MARKRES_CHECK(Box<Markchk>),
MARKRES_COUNT(Box<u64>),
}
#[derive(Debug, Eq, PartialEq)]
pub enum Markres_e {
MARKRES_OK = 1isize,
MARKRES_WAVE = 2isize,
MARKRES_CHECK = 3isize,
MARKRES_COUNT = 4isize,
MARKRES_ERR = -1isize,
}
#[derive(Debug, Eq, PartialEq)]
pub struct Objclass {
pub _class: Objclass_e,
}
#[derive(Debug, Eq, PartialEq)]
pub enum Objclass_e { OBJCLASS_E_DATA = 0isize, OBJCLASS_E_META = 1isize, }
#[derive(Debug, Eq, PartialEq)]
pub struct RBdbflush {
pub resp: Bdbflush,
}
#[derive(Debug, Eq, PartialEq)]
pub enum RDelobj { RDELOBJ_SUCCESS, RDELOBJ_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum RDelobj_e { RDELOBJ_SUCCESS = 0isize, RDELOBJ_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum RGetobj { RGETOBJ_SUCCESS(Iobufaddr), RGETOBJ_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum RGetobj_e { RGETOBJ_SUCCESS = 0isize, RGETOBJ_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum RHello { RHELLO_SUCCESS(Box<Virtinfo>), RHELLO_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum RHello_e { RHELLO_SUCCESS = 0isize, RHELLO_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum RMarkobj {
RMARKOBJ_SUCCESS(Vec<Markres>),
RMARKOBJ_ERROR(Box<Err>),
}
#[derive(Debug, Eq, PartialEq)]
pub enum RMarkobj_e { RMARKOBJ_SUCCESS = 0isize, RMARKOBJ_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum RPutobj { RPUTOBJ_SUCCESS, RPUTOBJ_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum RPutobj_e { RPUTOBJ_SUCCESS = 0isize, RPUTOBJ_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum RReclaim { RRECLAIM_SUCCESS, RRECLAIM_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum RReclaim_e { RRECLAIM_SUCCESS = 0isize, RRECLAIM_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum RStats { RSTATS_SUCCESS(Box<Storstats>), RSTATS_ERROR(Box<Err>), }
#[derive(Debug, Eq, PartialEq)]
pub enum RStats_e { RSTATS_SUCCESS = 0isize, RSTATS_ERROR = -1isize, }
#[derive(Debug, Eq, PartialEq)]
pub struct Smash {
pub hash: [u8; 20usize],
}
#[derive(Debug, Eq, PartialEq)]
pub enum Stormdata {
STORMSG_DETACHED(Box<Detached>),
STORMSG_THELLO(Box<THello>),
STORMSG_TPING,
STORMSG_TSTATS(Box<TStats>),
STORMSG_TGETOBJ(Box<TGetobj>),
STORMSG_TPUTOBJ(Box<TPutobj>),
STORMSG_TDELOBJ(Box<TDelobj>),
STORMSG_TMARKOBJ(Box<TMarkobj>),
STORMSG_TRECLAIM(Box<TReclaim>),
STORMSG_RHELLO(Box<RHello>),
STORMSG_RPING,
STORMSG_RSTATS(Box<RStats>),
STORMSG_RGETOBJ(Box<RGetobj>),
STORMSG_RPUTOBJ(Box<RPutobj>),
STORMSG_RDELOBJ(Box<RDelobj>),
STORMSG_RMARKOBJ(Box<RMarkobj>),
STORMSG_RRECLAIM(Box<RReclaim>),
DMSG_TBDBFLUSH(Box<TBdbflush>),
DMSG_RBDBFLUSH(Box<RBdbflush>),
}
#[derive(Debug, Eq, PartialEq)]
pub struct Stormhdr {
pub msgid: u32,
pub msgtype: Stormhdr_e,
}
#[derive(Debug, Eq, PartialEq)]
pub enum Stormhdr_e { STORMSG_ISREQUEST = 1isize, STORMSG_ISREPLY = 2isize, }
#[derive(Debug, Eq, PartialEq)]
pub enum Stormsg_e {
STORMSG_DETACHED = 0isize,
STORMSG_THELLO = 1isize,
STORMSG_TPING = 2isize,
STORMSG_TSTATS = 3isize,
STORMSG_TGETOBJ = 10isize,
STORMSG_TPUTOBJ = 11isize,
STORMSG_TDELOBJ = 12isize,
STORMSG_TMARKOBJ = 13isize,
STORMSG_TRECLAIM = 14isize,
DMSG_TBDBFLUSH = 23isize,
STORMSG_RHELLO = 101isize,
STORMSG_RPING = 102isize,
STORMSG_RSTATS = 103isize,
STORMSG_RGETOBJ = 110isize,
STORMSG_RPUTOBJ = 111isize,
STORMSG_RDELOBJ = 112isize,
STORMSG_RMARKOBJ = 113isize,
STORMSG_RRECLAIM = 114isize,
DMSG_RBDBFLUSH = 123isize,
}
#[derive(Debug, Eq, PartialEq)]
pub struct Storstats {
pub nblk: u64,
pub nused: u64,
pub nrsvd: u64,
pub stat: [u64; Storstats_e::STORSTAT_MAX as usize],
pub name: [char; STORSTAT_NAMELEN as usize],
}
#[derive(Debug, Eq, PartialEq)]
pub enum Storstats_e {
STORSTAT_NEWDBLK = 0isize,
STORSTAT_NEWDBYTES = 1isize,
STORSTAT_NEWMBLK = 2isize,
STORSTAT_NEWMBYTES = 3isize,
STORSTAT_DUPDBLK = 4isize,
STORSTAT_DUPDBYTES = 5isize,
STORSTAT_DUPMBLK = 6isize,
STORSTAT_DUPMBYTES = 7isize,
STORSTAT_REBALBLK = 8isize,
STORSTAT_REBALBYTES = 9isize,
STORSTAT_UPDATE = 10isize,
STORSTAT_MNEW = 11isize,
STORSTAT_MREPLACE = 12isize,
STORSTAT_MNOOP = 13isize,
STORSTAT_MAX = 14isize,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TBdbflush {
pub bdb: Smash,
pub flushop: Bdbflushop,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TDelobj {
pub storid: Smash,
pub objclass: Objclass,
pub objhash: Smash,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TGetobj {
pub storid: Smash,
pub objclass: Objclass,
pub objhash: Smash,
}
#[derive(Debug, Eq, PartialEq)]
pub struct THello {
pub major: uint,
pub minor: uint,
pub storid: Smash,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TMarkobj {
pub storid: Smash,
pub objclass: Objclass,
pub objhash: Smash,
pub curwave: Wave,
pub markops: Vec<Markop>,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TPutobj {
pub storid: Smash,
pub objclass: Objclass,
pub objhash: Smash,
pub curwave: Wave,
pub mark: Wave,
pub sgmark: Wave,
pub baddr: Iobufaddr,
pub placement: bool,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TReclaim {
pub storid: Smash,
pub wave: Wave,
}
#[derive(Debug, Eq, PartialEq)]
pub struct TStats {
pub storid: Smash,
}
#[derive(Debug, Eq, PartialEq)]
pub struct Virtinfo {
pub svid: Smash,
pub nvid: i32,
}
#[derive(Debug, Eq, PartialEq)]
pub struct Wave {
pub _wave: u64,
}
pub type uint = u32;
impl <Out: Write> Pack<Out> for Bdbflush {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
BDBFLUSH_SUCCESS => try!(0i32 . pack ( out )),
BDBFLUSH_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for Detached {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . err . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Err {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . ecode . pack ( out ));
try!(self . msg . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Iobufaddr {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . pack ( input ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Markchk {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . copies . pack ( out ));
try!(self . placement . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Markop {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . op . pack ( out ));
try!(self . wave . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Markres {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
MARKRES_OK => try!(1i32 . pack ( out )),
MARKRES_ERR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
MARKRES_WAVE(val) => {
try!(2i32 . pack ( out ));
try!(val . pack ( out ))
}
MARKRES_CHECK(val) => {
try!(3i32 . pack ( out ));
try!(val . pack ( out ))
}
MARKRES_COUNT(val) => {
try!(4i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for Objclass {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . _class . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for RBdbflush {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . resp . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for RDelobj {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RDELOBJ_SUCCESS => try!(0i32 . pack ( out )),
RDELOBJ_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for RGetobj {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RGETOBJ_SUCCESS(val) => {
try!(0i32 . pack ( out ));
try!(val . pack ( out ))
}
RGETOBJ_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for RHello {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RHELLO_SUCCESS(val) => {
try!(0i32 . pack ( out ));
try!(val . pack ( out ))
}
RHELLO_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for RMarkobj {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RMARKOBJ_SUCCESS(val) => {
try!(0i32 . pack ( out ));
try!(val . pack ( out ))
}
RMARKOBJ_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for RPutobj {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RPUTOBJ_SUCCESS => try!(0i32 . pack ( out )),
RPUTOBJ_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for RReclaim {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RRECLAIM_SUCCESS => try!(0i32 . pack ( out )),
RRECLAIM_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for RStats {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
RSTATS_SUCCESS(val) => {
try!(0i32 . pack ( out ));
try!(val . pack ( out ))
}
RSTATS_ERROR(val) => {
try!(-1i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for Smash {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . hash . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Stormdata {
fn pack(&self, out: &mut Out) -> Result<()> {
match self {
STORMSG_DETACHED(val) => {
try!(0i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_THELLO(val) => {
try!(1i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_TPING => try!(2i32 . pack ( out )),
STORMSG_TSTATS(val) => {
try!(3i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_TGETOBJ(val) => {
try!(10i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_TPUTOBJ(val) => {
try!(11i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_TDELOBJ(val) => {
try!(12i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_TMARKOBJ(val) => {
try!(13i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_TRECLAIM(val) => {
try!(14i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RHELLO(val) => {
try!(101i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RPING => try!(102i32 . pack ( out )),
STORMSG_RSTATS(val) => {
try!(103i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RGETOBJ(val) => {
try!(110i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RPUTOBJ(val) => {
try!(111i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RDELOBJ(val) => {
try!(112i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RMARKOBJ(val) => {
try!(113i32 . pack ( out ));
try!(val . pack ( out ))
}
STORMSG_RRECLAIM(val) => {
try!(114i32 . pack ( out ));
try!(val . pack ( out ))
}
DMSG_TBDBFLUSH(val) => {
try!(23i32 . pack ( out ));
try!(val . pack ( out ))
}
DMSG_RBDBFLUSH(val) => {
try!(123i32 . pack ( out ));
try!(val . pack ( out ))
}
};
Ok(())
}
}
impl <Out: Write> Pack<Out> for Stormhdr {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . msgid . pack ( out ));
try!(self . msgtype . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Storstats {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . nblk . pack ( out ));
try!(self . nused . pack ( out ));
try!(self . nrsvd . pack ( out ));
try!(self . stat . pack ( out ));
try!(self . name . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TBdbflush {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . bdb . pack ( out ));
try!(self . flushop . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TDelobj {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . storid . pack ( out ));
try!(self . objclass . pack ( out ));
try!(self . objhash . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TGetobj {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . storid . pack ( out ));
try!(self . objclass . pack ( out ));
try!(self . objhash . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for THello {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . major . pack ( out ));
try!(self . minor . pack ( out ));
try!(self . storid . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TMarkobj {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . storid . pack ( out ));
try!(self . objclass . pack ( out ));
try!(self . objhash . pack ( out ));
try!(self . curwave . pack ( out ));
try!(self . markops . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TPutobj {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . storid . pack ( out ));
try!(self . objclass . pack ( out ));
try!(self . objhash . pack ( out ));
try!(self . curwave . pack ( out ));
try!(self . mark . pack ( out ));
try!(self . sgmark . pack ( out ));
try!(self . baddr . pack ( out ));
try!(self . placement . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TReclaim {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . storid . pack ( out ));
try!(self . wave . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for TStats {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . storid . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Virtinfo {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . svid . pack ( out ));
try!(self . nvid . pack ( out ));
Ok(())
}
}
impl <Out: Write> Pack<Out> for Wave {
fn pack(&self, out: &mut Out) -> Result<()> {
try!(self . _wave . pack ( out ));
Ok(())
}
}
impl <In: Read> Unpack<In> for Bdbflush {
fn unpack(input: &mut In) -> Result<Bdbflush> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 => Bdbflush::BDBFLUSH_SUCCESS,
-1i32 =>
Bdbflush::BDBFLUSH_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for Detached {
fn unpack(input: &mut In) -> Result<Detached> {
Ok(Detached{err: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Err {
fn unpack(input: &mut In) -> Result<Err> {
Ok(Err{ecode: try!(Unpack:: unpack ( input )),
msg: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Iobufaddr {
fn unpack(input: &mut In) -> Result<Iobufaddr> {
Ok(try!(Unpack:: unpack ( input )))
}
}
impl <In: Read> Unpack<In> for Markchk {
fn unpack(input: &mut In) -> Result<Markchk> {
Ok(Markchk{copies: try!(Unpack:: unpack ( input )),
placement: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Markop {
fn unpack(input: &mut In) -> Result<Markop> {
Ok(Markop{op: try!(Unpack:: unpack ( input )),
wave: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Markres {
fn unpack(input: &mut In) -> Result<Markres> {
Ok(match try!(Unpack:: unpack ( input )) {
1i32 => Markres::MARKRES_OK,
-1i32 => Markres::MARKRES_ERR(try!(Unpack:: unpack ( input ))),
2i32 => Markres::MARKRES_WAVE(try!(Unpack:: unpack ( input ))),
3i32 =>
Markres::MARKRES_CHECK(try!(Unpack:: unpack ( input ))),
4i32 =>
Markres::MARKRES_COUNT(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for Objclass {
fn unpack(input: &mut In) -> Result<Objclass> {
Ok(Objclass{_class: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for RBdbflush {
fn unpack(input: &mut In) -> Result<RBdbflush> {
Ok(RBdbflush{resp: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for RDelobj {
fn unpack(input: &mut In) -> Result<RDelobj> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 => RDelobj::RDELOBJ_SUCCESS,
-1i32 =>
RDelobj::RDELOBJ_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for RGetobj {
fn unpack(input: &mut In) -> Result<RGetobj> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 =>
RGetobj::RGETOBJ_SUCCESS(try!(Unpack:: unpack ( input ))),
-1i32 =>
RGetobj::RGETOBJ_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for RHello {
fn unpack(input: &mut In) -> Result<RHello> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 =>
RHello::RHELLO_SUCCESS(try!(Unpack:: unpack ( input ))),
-1i32 => RHello::RHELLO_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for RMarkobj {
fn unpack(input: &mut In) -> Result<RMarkobj> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 =>
RMarkobj::RMARKOBJ_SUCCESS(try!(Unpack:: unpack ( input ))),
-1i32 =>
RMarkobj::RMARKOBJ_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for RPutobj {
fn unpack(input: &mut In) -> Result<RPutobj> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 => RPutobj::RPUTOBJ_SUCCESS,
-1i32 =>
RPutobj::RPUTOBJ_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for RReclaim {
fn unpack(input: &mut In) -> Result<RReclaim> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 => RReclaim::RRECLAIM_SUCCESS,
-1i32 =>
RReclaim::RRECLAIM_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for RStats {
fn unpack(input: &mut In) -> Result<RStats> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 =>
RStats::RSTATS_SUCCESS(try!(Unpack:: unpack ( input ))),
-1i32 => RStats::RSTATS_ERROR(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for Smash {
fn unpack(input: &mut In) -> Result<Smash> {
Ok(Smash{hash:
[try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input ))],})
}
}
impl <In: Read> Unpack<In> for Stormdata {
fn unpack(input: &mut In) -> Result<Stormdata> {
Ok(match try!(Unpack:: unpack ( input )) {
0i32 =>
Stormdata::STORMSG_DETACHED(try!(Unpack:: unpack ( input ))),
1i32 =>
Stormdata::STORMSG_THELLO(try!(Unpack:: unpack ( input ))),
2i32 => Stormdata::STORMSG_TPING,
3i32 =>
Stormdata::STORMSG_TSTATS(try!(Unpack:: unpack ( input ))),
10i32 =>
Stormdata::STORMSG_TGETOBJ(try!(Unpack:: unpack ( input ))),
11i32 =>
Stormdata::STORMSG_TPUTOBJ(try!(Unpack:: unpack ( input ))),
12i32 =>
Stormdata::STORMSG_TDELOBJ(try!(Unpack:: unpack ( input ))),
13i32 =>
Stormdata::STORMSG_TMARKOBJ(try!(Unpack:: unpack ( input ))),
14i32 =>
Stormdata::STORMSG_TRECLAIM(try!(Unpack:: unpack ( input ))),
101i32 =>
Stormdata::STORMSG_RHELLO(try!(Unpack:: unpack ( input ))),
102i32 => Stormdata::STORMSG_RPING,
103i32 =>
Stormdata::STORMSG_RSTATS(try!(Unpack:: unpack ( input ))),
110i32 =>
Stormdata::STORMSG_RGETOBJ(try!(Unpack:: unpack ( input ))),
111i32 =>
Stormdata::STORMSG_RPUTOBJ(try!(Unpack:: unpack ( input ))),
112i32 =>
Stormdata::STORMSG_RDELOBJ(try!(Unpack:: unpack ( input ))),
113i32 =>
Stormdata::STORMSG_RMARKOBJ(try!(Unpack:: unpack ( input ))),
114i32 =>
Stormdata::STORMSG_RRECLAIM(try!(Unpack:: unpack ( input ))),
23i32 =>
Stormdata::DMSG_TBDBFLUSH(try!(Unpack:: unpack ( input ))),
123i32 =>
Stormdata::DMSG_RBDBFLUSH(try!(Unpack:: unpack ( input ))),
_ => return Err(xdr::Error::invalid()),
})
}
}
impl <In: Read> Unpack<In> for Stormhdr {
fn unpack(input: &mut In) -> Result<Stormhdr> {
Ok(Stormhdr{msgid: try!(Unpack:: unpack ( input )),
msgtype: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Storstats {
fn unpack(input: &mut In) -> Result<Storstats> {
Ok(Storstats{nblk: try!(Unpack:: unpack ( input )),
nused: try!(Unpack:: unpack ( input )),
nrsvd: try!(Unpack:: unpack ( input )),
stat:
[try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input ))],
name:
[try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input )),
try!(Unpack:: unpack ( input ))],})
}
}
impl <In: Read> Unpack<In> for TBdbflush {
fn unpack(input: &mut In) -> Result<TBdbflush> {
Ok(TBdbflush{bdb: try!(Unpack:: unpack ( input )),
flushop: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for TDelobj {
fn unpack(input: &mut In) -> Result<TDelobj> {
Ok(TDelobj{storid: try!(Unpack:: unpack ( input )),
objclass: try!(Unpack:: unpack ( input )),
objhash: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for TGetobj {
fn unpack(input: &mut In) -> Result<TGetobj> {
Ok(TGetobj{storid: try!(Unpack:: unpack ( input )),
objclass: try!(Unpack:: unpack ( input )),
objhash: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for THello {
fn unpack(input: &mut In) -> Result<THello> {
Ok(THello{major: try!(Unpack:: unpack ( input )),
minor: try!(Unpack:: unpack ( input )),
storid: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for TMarkobj {
fn unpack(input: &mut In) -> Result<TMarkobj> {
Ok(TMarkobj{storid: try!(Unpack:: unpack ( input )),
objclass: try!(Unpack:: unpack ( input )),
objhash: try!(Unpack:: unpack ( input )),
curwave: try!(Unpack:: unpack ( input )),
markops: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for TPutobj {
fn unpack(input: &mut In) -> Result<TPutobj> {
Ok(TPutobj{storid: try!(Unpack:: unpack ( input )),
objclass: try!(Unpack:: unpack ( input )),
objhash: try!(Unpack:: unpack ( input )),
curwave: try!(Unpack:: unpack ( input )),
mark: try!(Unpack:: unpack ( input )),
sgmark: try!(Unpack:: unpack ( input )),
baddr: try!(Unpack:: unpack ( input )),
placement: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for TReclaim {
fn unpack(input: &mut In) -> Result<TReclaim> {
Ok(TReclaim{storid: try!(Unpack:: unpack ( input )),
wave: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for TStats {
fn unpack(input: &mut In) -> Result<TStats> {
Ok(TStats{storid: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Virtinfo {
fn unpack(input: &mut In) -> Result<Virtinfo> {
Ok(Virtinfo{svid: try!(Unpack:: unpack ( input )),
nvid: try!(Unpack:: unpack ( input )),})
}
}
impl <In: Read> Unpack<In> for Wave {
fn unpack(input: &mut In) -> Result<Wave> {
Ok(Wave{_wave: try!(Unpack:: unpack ( input )),})
}
}