1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

use time::Timespec;
use std::ops::Deref;
use std::fmt::{Display, Formatter, Error as FmtError, LowerHex};

///Trait for obtained packets - common part between borrowed and owned versions.
pub trait Packet : Deref<Target=[u8]> + Display{
    ///Returns the time when this packet was received.
    fn when(&self) -> Timespec;
}

///Structure representing obtained raw packet - borrowed version.
#[derive(Debug)]
pub struct BorrowedPacket<'a> {
    when_received: Timespec,
    packet: &'a[u8],
    //_marker: PhantomData<&'a mut u32>
}

impl<'a> BorrowedPacket<'a> {
    ///Creates a new Packet instance.
    pub fn new(when_received: Timespec, data: &'a[u8]) -> BorrowedPacket<'a> {
        BorrowedPacket{
            when_received,
            packet: data,
            //_marker: PhantomData
        }
    }
    ///Converts Borrowed packet into owned version.
    pub fn as_owned(&self) -> OwnedPacket {
        OwnedPacket::new(self.packet, self.when_received)
    }
    ///Converts Borrowed packet into owned version.
    pub fn into_owned(self) -> OwnedPacket {
        OwnedPacket::new(self.packet, self.when_received)
    }
}

impl<'a> Deref for BorrowedPacket<'a> {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        self.packet
    }
}

impl<'a> Packet for BorrowedPacket<'a> {

    fn when(&self) -> Timespec {
        self.when_received
    }
}

impl<'a> Display for BorrowedPacket<'a> {
    fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
        for b in self.packet {
            LowerHex::fmt(b, f)?;
        }
        Ok(())
    }
}

///Structure representing obtained raw packet - owned version.
pub struct OwnedPacket {
    when_received: Timespec,
    packet: Vec<u8>
}

impl Packet for OwnedPacket{

    fn when(&self) -> Timespec {
        self.when_received
    }
}

impl Deref for OwnedPacket {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.packet
    }
}

impl Display for OwnedPacket {
    fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
        for b in &self.packet {
            LowerHex::fmt(b, f)?;
        }
        Ok(())
    }
}

impl OwnedPacket {
    ///Creates owned packet from provided data.
    pub fn new (data: &[u8], when: Timespec) -> Self{
        OwnedPacket {
            packet: data.into(),
            when_received: when
        }
    }

    ///Returns its borrowed version.
    pub fn as_borrowed(&self) -> BorrowedPacket {
        BorrowedPacket::new(self.when_received, &self.packet)
    }
}