src/command.rs

   1 use std::io;
   2 use std::rand::{ random, task_rng, distributions };
   3 use std::rand::distributions::IndependentSample;
   4
   5 pub enum ReadingError {
   6    ReadIOError(io::IoError)
   7    // TODO...
   8 }
   9
  10 pub enum WritingError {
  11    WriteIOError(io::IoError)
  12    // TODO...
  13 }
  14
  15 pub type ReadingResult = Result<Packet, ReadingError>;
  16 pub type WritingResult = Result<(), WritingError>;
  17
  18 pub enum PacketType {
  19    CommandType,
  20    AnswerType
  21 }
  22
  23 pub struct CommandPacket {
  24    t: PacketType,
  25    timestamp: u64,
  26    commandID: u8,
  27    commandPayload: Vec<u8>
  28 }
  29
  30 pub struct ErrorPacket {
  31    timestamp: u64
  32 }
  33
  34 pub enum Packet {
  35    Command(CommandPacket),
  36    Error(ErrorPacket)
  37 }
  38
  39 impl Packet {
  40    pub fn newRandomCommand(timestamp: u64) -> Packet {
  41
  42       let mut rng = task_rng();
  43       Command(CommandPacket {
  44          t: CommandType,
  45          timestamp: timestamp,
  46          commandID: random::<u8>(),
  47          commandPayload: Vec::from_fn(distributions::Range::new(7u, 40u).ind_sample(&mut rng), |idx| 0u8)
  48       })
  49    }
  50
  51    pub fn write(&self, output: &mut io::Writer) ->  WritingResult {
  52
  53       match self {
  54          &Command(ref command) => {
  55             output.write_u8(0);
  56             output.write_be_u64(command.timestamp);
  57
  58
  59          },
  60          &Error(error) => ()
  61       }
  62
  63       Ok(())
  64    }
  65
  66    pub fn read(input: &mut io::Reader) -> ReadingResult {
  67       Ok(Packet::newRandomCommand(0))
  68    }
  69 }