[−][src]Trait rdp::model::data::Message

pub trait Message: Send {
    fn write(&self, writer: &mut dyn Write) -> RdpResult<()>;

    fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>;

    fn length(&self) -> u64;

    fn visit(&self) -> DataType;

    fn options(&self) -> MessageOption;
}

All is a message

A message can be Read or Write from a Stream

Required methods

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>

Write node to the Stream

Write current element into a writable stream

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>

Read node from stream

Read and set current variable from readable stream

fn length(&self) -> u64

Length in bytes of current element

fn visit(&self) -> DataType

Cast value on Message Tree

Visit value and try to return inner type This is based on Tree visitor pattern

fn options(&self) -> MessageOption

Retrieve options of a subtype

Allow subtype to show some options That will impact current operation on parent like skipping some fields of a component

Loading content...

Implementations on Foreign Types

impl Message for u8[src]

u8 message

Implement Message trait for basic type u8

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write u8 value into stream

Example

    let mut s = Cursor::new(Vec::new());
    let value : u8 = 8;
    value.write(&mut s);
    assert_eq!(*s.get_ref(), vec![8 as u8]);

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read u8 value from stream

Example

    let mut stream = Cursor::new(vec![8]);
    let mut value = 0 as u8;
    value.read(&mut stream); // set the value according to stream content
    assert_eq!(value, 8);

fn length(&self) -> u64[src]

Size in byte of wrapped value 1 in case of u8

Example

    let x : u8 = 0;
    assert_eq!(x.length(), 1);

fn visit(&self) -> DataType[src]

Use visitor pattern to retrieve leaf value in case of node component

Example

    let x : u8 = 8;
    if let DataType::U8(value) = x.visit() {
        assert_eq!(value, 8)
    }
    else {
        panic!("Invalid cast");
    }

fn options(&self) -> MessageOption[src]

Retrieve option of a subnode

Allow a parent to retrieve some optional value That will influence the current node operation like skipping field of a component

This kind of node have no option

impl Message for Vec<u8>[src]

impl<T: Message> Message for Option<T>[src]

This is an optional fields Actually always write but read if and only if the reader buffer could read the size of inner Message

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write an optional message Actually always try to write

Example

use std::io::Cursor;
use rdp::model::data::Message;
let mut s1 = Cursor::new(vec![]);
Some(4).write(&mut s1);
assert_eq!(s1.into_inner(), [4]);
let mut s2 = Cursor::new(vec![]);
Option::<u8>::None.write(&mut s2);
assert_eq!(s2.into_inner(), [])

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read an optional field Read the value if and only if there is enough space in the reader

Example

#[macro_use]
    let mut s1 = Cursor::new(vec![1, 0, 0, 0]);
    let mut x = Some(U32::LE(0));
    x.read(&mut s1);
    assert_eq!(1, cast!(DataType::U32, x).unwrap());

    let mut s2 = Cursor::new(vec![1, 0, 0]);
    let mut y = Some(U32::LE(0));
    y.read(&mut s2);
    assert!(y == None);

    let mut s3 = Cursor::new(vec![1, 0, 0]);
    // case in component
    let mut z = component![
        "optional" => Some(U32::LE(0))
    ];
    z.read(&mut s3);
    assert!(is_none!(z["optional"]))

fn length(&self) -> u64[src]

This compute the length of the optionaln field

Example

use rdp::model::data::{U32, Message};
assert_eq!(Some(U32::LE(4)).length(), 4);
assert_eq!(Option::<U32>::None.length(), 0);

fn visit(&self) -> DataType[src]

Visitor pattern for optional field

Example

#[macro_use]
    assert_eq!(4, cast!(DataType::U32, Some(U32::LE(4))).unwrap());
    assert!(is_none!(Option::<U32>::None));
Loading content...

Implementors

impl Message for Component[src]

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write a component message Useful to better reading structure and have some dynamic option

Example

    let mut s = Cursor::new(vec![]);
    let mut x = component![
        "field1" => 3 as u8,
        "field2" => U32::LE(6)
    ];
    x.write(&mut s);
    assert_eq!(s.into_inner(), [3, 6, 0, 0, 0])

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read a component base pattern from a valid stream

Example

    let mut s = Cursor::new(vec![3, 6, 0, 0, 0]);
    let mut x = component![
        "field1" => 0 as u8,
        "field2" => U32::LE(0)
    ];
    x.read(&mut s);
    assert_eq!(cast!(DataType::U32, x["field2"]).unwrap(), 6)

fn length(&self) -> u64[src]

Compute the length in byte of the component

Example

    let mut s = Cursor::new(vec![3, 6, 0, 0, 0]);
    let mut x = component![
        "field1" => 0 as u8,
        "field2" => U32::LE(0)
    ];
    x.read(&mut s);
    assert_eq!(x.length(), 5)

fn visit(&self) -> DataType[src]

Cast a dyn Message into component

Example

    let mut s = Cursor::new(vec![8, 3, 0, 0, 0, 0]);
    let mut x = trame![
        component![
            "field1" => 0 as u8,
            "field2" => U32::LE(0)
        ],
        0 as u8
    ];
    x.read(&mut s);
    let y = cast!(DataType::Component, x[0]).unwrap();
    assert_eq!(cast!(DataType::U32, y["field2"]).unwrap(), 3)

fn options(&self) -> MessageOption[src]

A component have no option by default

impl Message for Trame[src]

Trame is a Message too

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write a trame to a stream

Write all subnode of the trame to the stream This can be view as anonymous node

Example

    let mut s = Cursor::new(Vec::new());
    let x = trame![0 as u8, U32::LE(2)];
    x.write(&mut s);
    assert_eq!(s.into_inner(), [0, 2, 0, 0, 0])

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read a trame from a stream

Read all subnode from a stream

Example

    let mut s = Cursor::new(vec![8, 3, 0, 0, 0]);
    let mut x = trame![0 as u8, U32::LE(0)];
    x.read(&mut s);
    assert_eq!(cast!(DataType::U8, x[0]).unwrap(), 8);
    assert_eq!(cast!(DataType::U32, x[1]).unwrap(), 3);

fn length(&self) -> u64[src]

Length in byte of the entire trame

Example

    let mut s = Cursor::new(Vec::new());
    let x = trame![0 as u8, U32::LE(2)];
    x.write(&mut s);
    assert_eq!(x.length(), 5)

fn visit(&self) -> DataType[src]

Allow to cast a message into trame

Example

    let mut s = Cursor::new(vec![8, 3, 0, 0, 0, 0]);
    let mut x = trame![trame![0 as u8, U32::LE(0)], 0 as u8];
    x.read(&mut s);
    let y = cast!(DataType::Trame, x[0]).unwrap();
    assert_eq!(cast!(DataType::U32, y[1]).unwrap(), 3)

fn options(&self) -> MessageOption[src]

A trame have no options

impl Message for U16[src]

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write an unsigned 16 bits value

Example

use std::io::Cursor;
use rdp::model::data::{U16, Message};
let mut s1 = Cursor::new(vec![]);
U16::LE(4).write(&mut s1).unwrap();
assert_eq!(s1.into_inner(), [4, 0]);
let mut s2 = Cursor::new(vec![]);
U16::BE(4).write(&mut s2).unwrap();
assert_eq!(s2.into_inner(), [0, 4]);

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read an Unsigned 16 bits value from a stream

Example

use std::io::Cursor;
use rdp::model::data::{U16, Message};
let mut s1 = Cursor::new(vec![4, 0]);
let mut v1 = U16::LE(0);
v1.read(&mut s1).unwrap();
assert_eq!(v1.inner(), 4);
let mut s2 = Cursor::new(vec![0, 4]);
let mut v2 = U16::BE(0);
v2.read(&mut s2).unwrap();
assert_eq!(v2.inner(), 4);

fn length(&self) -> u64[src]

Length of U16 is 2

fn visit(&self) -> DataType[src]

Use to cast an anonymous Message into U16

Example

    let mut s = Cursor::new(vec![8, 0, 3]);
    let mut x = trame![
        U16::LE(0),
        0 as u8
    ];
    x.read(&mut s);
    assert_eq!(cast!(DataType::U16, x[0]).unwrap(), 8)

fn options(&self) -> MessageOption[src]

No options

impl Message for U32[src]

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write an unsigned 32 bits value

Example

use std::io::Cursor;
use rdp::model::data::{U32, Message};
let mut s1 = Cursor::new(vec![]);
U32::LE(4).write(&mut s1).unwrap();
assert_eq!(s1.into_inner(), [4, 0, 0, 0]);
let mut s2 = Cursor::new(vec![]);
U32::BE(4).write(&mut s2).unwrap();
assert_eq!(s2.into_inner(), [0, 0, 0, 4]);

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read an Unsigned 16 bits value from a stream

Example

use std::io::Cursor;
use rdp::model::data::{U32, Message};
let mut s1 = Cursor::new(vec![4, 0, 0, 0]);
let mut v1 = U32::LE(0);
v1.read(&mut s1).unwrap();
assert_eq!(v1.inner(), 4);
let mut s2 = Cursor::new(vec![0, 0, 0, 4]);
let mut v2 = U32::BE(0);
v2.read(&mut s2).unwrap();
assert_eq!(v2.inner(), 4);

fn length(&self) -> u64[src]

Length of the 32 bits is four

fn visit(&self) -> DataType[src]

Use to cast an anonymous Message into U32

Example

    let mut s = Cursor::new(vec![8, 0, 0, 0, 3]);
    let mut x = trame![
        U32::LE(0),
        0 as u8
    ];
    x.read(&mut s);
    assert_eq!(cast!(DataType::U32, x[0]).unwrap(), 8)

fn options(&self) -> MessageOption[src]

No options

impl<T: 'static + Message> Message for Array<T>[src]

Implement the message trait for Array

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Write an array You may not use even if it works prefer using trame object

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Read a dynamic array

Example

use std::io::Cursor;
use rdp::model::data::{U16, Array, Message};
let mut s = Cursor::new(vec![0, 0, 1, 0]);
let mut dyn_array = Array::new(|| U16::LE(0));
dyn_array.read(&mut s);
assert_eq!(dyn_array.as_ref().len(), 2)

fn length(&self) -> u64[src]

This is the length of the inner trame

Example

use std::io::Cursor;
use rdp::model::data::{U16, Array, Message};
let mut s = Cursor::new(vec![0, 0, 1, 0]);
let mut dyn_array = Array::new(|| U16::LE(0));
dyn_array.read(&mut s);
assert_eq!(dyn_array.length(), 4)

fn visit(&self) -> DataType[src]

Visit the inner trame It's means always return a slice Prefer using as_ref and visit

fn options(&self) -> MessageOption[src]

This kind of message have no option

impl<T: Message + Clone + PartialEq> Message for Check<T>[src]

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Check values doesn't happen during write steps

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Check value will be made during reading steps

Example

use rdp::model::data::{Check, U16, Message};
use std::io::Cursor;
let mut s = Cursor::new(vec![4, 0]);
let mut x = Check::new(U16::LE(4));
assert!(!x.read(&mut s).is_err());

let mut s2 = Cursor::new(vec![5, 0]);
assert!(x.read(&mut s2).is_err());

fn length(&self) -> u64[src]

This is the length of the inner value

fn visit(&self) -> DataType[src]

Same as visit of the inner value

Example

    let mut s = Cursor::new(vec![8, 0, 0, 0, 3]);
    let mut x = trame![
        Check::new(U32::LE(8)),
        0 as u8
    ];
    x.read(&mut s);
    assert_eq!(cast!(DataType::U32, x[0]).unwrap(), 8)

fn options(&self) -> MessageOption[src]

No option

impl<T: Message> Message for DynOption<T>[src]

Dynamic option is a transparent object for the inner

fn write(&self, writer: &mut dyn Write) -> RdpResult<()>[src]

Transparent

fn read(&mut self, reader: &mut dyn Read) -> RdpResult<()>[src]

Transparent

fn length(&self) -> u64[src]

Transparent

fn visit(&self) -> DataType[src]

Transparent

fn options(&self) -> MessageOption[src]

Transparent

Loading content...