generated-code.rs

// GENERATED CODE
//
// Generated from /home/chris/repos/glusterfs/rpc/xdr/src/rpc-common-xdr.x.
//
// DO NOT EDIT


#[derive(Debug, Eq, PartialEq, Clone, Copy)]
pub struct auth_glusterfs_parms {
    pub lk_owner: i64,
    pub pid: u32,
    pub uid: u32,
    pub gid: u32,
    pub ngrps: u32,
    pub groups: [u32; 16i64 as usize],
}

#[derive(Debug, Eq, PartialEq, Clone)]
pub struct auth_glusterfs_parms_v2 {
    pub pid: i32,
    pub uid: u32,
    pub gid: u32,
    pub groups: Vec<u32>,
    pub lk_owner: Vec<u8>,
}

#[derive(Debug, Eq, PartialEq, Clone)]
pub struct gf_common_rsp {
    pub op_ret: i32,
    pub op_errno: i32,
    pub xdata: Vec<u8>,
}

#[derive(Debug, Eq, PartialEq, Clone, Copy)]
pub struct gf_dump_req {
    pub gfs_id: i64,
}

#[derive(Debug, Eq, PartialEq, Clone)]
pub struct gf_dump_rsp {
    pub gfs_id: i64,
    pub op_ret: i32,
    pub op_errno: i32,
    pub prog: Option<Box<gf_prog_detail>>,
}

#[derive(Debug, Eq, PartialEq, Clone)]
pub struct gf_prog_detail {
    pub progname: String,
    pub prognum: i64,
    pub progver: i64,
    pub next: Option<Box<gf_prog_detail>>,
}

pub type u_quad_t = u64;

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for auth_glusterfs_parms {
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(self . lk_owner . pack ( out )) +
               try!(self . pid . pack ( out )) +
               try!(self . uid . pack ( out )) +
               try!(self . gid . pack ( out )) +
               try!(self . ngrps . pack ( out )) +
               try!(xdr_codec :: pack_array (
                    & self . groups [ .. ] , self . groups . len (  ) , out ,
                    None )) + 0)
    }
}

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for auth_glusterfs_parms_v2
 {
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(self . pid . pack ( out )) + try!(self . uid . pack ( out )) +
               try!(self . gid . pack ( out )) +
               try!(xdr_codec :: pack_flex ( & self . groups , None , out )) +
               try!(xdr_codec :: pack_opaque_flex (
                    & self . lk_owner , None , out )) + 0)
    }
}

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for gf_common_rsp {
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(self . op_ret . pack ( out )) +
               try!(self . op_errno . pack ( out )) +
               try!(xdr_codec :: pack_opaque_flex (
                    & self . xdata , None , out )) + 0)
    }
}

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for gf_dump_req {
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(self . gfs_id . pack ( out )) + 0)
    }
}

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for gf_dump_rsp {
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(self . gfs_id . pack ( out )) +
               try!(self . op_ret . pack ( out )) +
               try!(self . op_errno . pack ( out )) +
               try!(self . prog . pack ( out )) + 0)
    }
}

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for gf_prog_detail {
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(xdr_codec :: pack_string ( & self . progname , None , out )) +
               try!(self . prognum . pack ( out )) +
               try!(self . progver . pack ( out )) +
               try!(self . next . pack ( out )) + 0)
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for auth_glusterfs_parms {
    fn unpack(input: &mut In)
     -> xdr_codec::Result<(auth_glusterfs_parms, usize)> {
        let mut sz = 0;
        Ok((auth_glusterfs_parms{lk_owner:
                                     {
                                         let (v, fsz) =
                                             try!(xdr_codec :: Unpack ::
                                                  unpack ( input ));
                                         sz += fsz;
                                         v
                                     },
                                 pid:
                                     {
                                         let (v, fsz) =
                                             try!(xdr_codec :: Unpack ::
                                                  unpack ( input ));
                                         sz += fsz;
                                         v
                                     },
                                 uid:
                                     {
                                         let (v, fsz) =
                                             try!(xdr_codec :: Unpack ::
                                                  unpack ( input ));
                                         sz += fsz;
                                         v
                                     },
                                 gid:
                                     {
                                         let (v, fsz) =
                                             try!(xdr_codec :: Unpack ::
                                                  unpack ( input ));
                                         sz += fsz;
                                         v
                                     },
                                 ngrps:
                                     {
                                         let (v, fsz) =
                                             try!(xdr_codec :: Unpack ::
                                                  unpack ( input ));
                                         sz += fsz;
                                         v
                                     },
                                 groups:
                                     {
                                         let (v, fsz) =
                                             {
                                                 use std::mem;
                                                 let mut buf:
                                                         [u32; 16i64 as
                                                                   usize] =
                                                     unsafe {
                                                         mem::uninitialized()
                                                     };
                                                 let sz =
                                                     try!(xdr_codec ::
                                                          unpack_array (
                                                          input , & mut buf [
                                                          .. ] , 16i64 as
                                                          usize , None ));
                                                 (buf, sz)
                                             };
                                         sz += fsz;
                                         v
                                     },}, sz))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for auth_glusterfs_parms_v2 {
    fn unpack(input: &mut In)
     -> xdr_codec::Result<(auth_glusterfs_parms_v2, usize)> {
        let mut sz = 0;
        Ok((auth_glusterfs_parms_v2{pid:
                                        {
                                            let (v, fsz) =
                                                try!(xdr_codec :: Unpack ::
                                                     unpack ( input ));
                                            sz += fsz;
                                            v
                                        },
                                    uid:
                                        {
                                            let (v, fsz) =
                                                try!(xdr_codec :: Unpack ::
                                                     unpack ( input ));
                                            sz += fsz;
                                            v
                                        },
                                    gid:
                                        {
                                            let (v, fsz) =
                                                try!(xdr_codec :: Unpack ::
                                                     unpack ( input ));
                                            sz += fsz;
                                            v
                                        },
                                    groups:
                                        {
                                            let (v, fsz) =
                                                try!(xdr_codec :: unpack_flex
                                                     ( input , None ));
                                            sz += fsz;
                                            v
                                        },
                                    lk_owner:
                                        {
                                            let (v, fsz) =
                                                try!(xdr_codec ::
                                                     unpack_opaque_flex (
                                                     input , None ));
                                            sz += fsz;
                                            v
                                        },}, sz))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for gf_common_rsp {
    fn unpack(input: &mut In) -> xdr_codec::Result<(gf_common_rsp, usize)> {
        let mut sz = 0;
        Ok((gf_common_rsp{op_ret:
                              {
                                  let (v, fsz) =
                                      try!(xdr_codec :: Unpack :: unpack (
                                           input ));
                                  sz += fsz;
                                  v
                              },
                          op_errno:
                              {
                                  let (v, fsz) =
                                      try!(xdr_codec :: Unpack :: unpack (
                                           input ));
                                  sz += fsz;
                                  v
                              },
                          xdata:
                              {
                                  let (v, fsz) =
                                      try!(xdr_codec :: unpack_opaque_flex (
                                           input , None ));
                                  sz += fsz;
                                  v
                              },}, sz))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for gf_dump_req {
    fn unpack(input: &mut In) -> xdr_codec::Result<(gf_dump_req, usize)> {
        let mut sz = 0;
        Ok((gf_dump_req{gfs_id:
                            {
                                let (v, fsz) =
                                    try!(xdr_codec :: Unpack :: unpack ( input
                                         ));
                                sz += fsz;
                                v
                            },}, sz))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for gf_dump_rsp {
    fn unpack(input: &mut In) -> xdr_codec::Result<(gf_dump_rsp, usize)> {
        let mut sz = 0;
        Ok((gf_dump_rsp{gfs_id:
                            {
                                let (v, fsz) =
                                    try!(xdr_codec :: Unpack :: unpack ( input
                                         ));
                                sz += fsz;
                                v
                            },
                        op_ret:
                            {
                                let (v, fsz) =
                                    try!(xdr_codec :: Unpack :: unpack ( input
                                         ));
                                sz += fsz;
                                v
                            },
                        op_errno:
                            {
                                let (v, fsz) =
                                    try!(xdr_codec :: Unpack :: unpack ( input
                                         ));
                                sz += fsz;
                                v
                            },
                        prog:
                            {
                                let (v, fsz) =
                                    try!(xdr_codec :: Unpack :: unpack ( input
                                         ));
                                sz += fsz;
                                v
                            },}, sz))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for gf_prog_detail {
    fn unpack(input: &mut In) -> xdr_codec::Result<(gf_prog_detail, usize)> {
        let mut sz = 0;
        Ok((gf_prog_detail{progname:
                               {
                                   let (v, fsz) =
                                       try!(xdr_codec :: unpack_string (
                                            input , None ));
                                   sz += fsz;
                                   v
                               },
                           prognum:
                               {
                                   let (v, fsz) =
                                       try!(xdr_codec :: Unpack :: unpack (
                                            input ));
                                   sz += fsz;
                                   v
                               },
                           progver:
                               {
                                   let (v, fsz) =
                                       try!(xdr_codec :: Unpack :: unpack (
                                            input ));
                                   sz += fsz;
                                   v
                               },
                           next:
                               {
                                   let (v, fsz) =
                                       try!(xdr_codec :: Unpack :: unpack (
                                            input ));
                                   sz += fsz;
                                   v
                               },}, sz))
    }
}