Struct iostream::io::memory::memory_stream::MemoryStream

pub struct MemoryStream { /* fields omitted */ }

the memory stream from memory,you can use it,wr memory

Methods

impl MemoryStream

pub fn new() -> MemoryStream

pub fn new_to(buf: &[u8]) -> MemoryStream

impl MemoryStream

pub fn to_vec(&self) -> Vec<u8>

return current stream data to Vec

pub fn clear(&mut self)

Clears the vector, removing all values,and set position =0

Trait Implementations

impl Stream for MemoryStream

fn set_position(&mut self, _potion: u64) -> Result<(), Box<dyn Error>>

gets or sets the position within the current stream

fn position(&mut self) -> u64

The current position within the stream.

fn length(&mut self) -> u64

A long value representing the length of the stream in bytes.

fn set_length(&mut self, len: u64) -> Result<(), Box<dyn Error>>

Sets the length of this stream to the given value.

fn can_write(&mut self) -> bool

gets a value indicating whether the current stream supports writing. true if the stream supports writing; otherwise, false.

fn can_read(&mut self) -> bool

gets a value indicating whether the current stream supports reading. true if the stream supports reading; otherwise, false.

fn can_seek(&mut self) -> bool

gets a value indicating whether the current stream supports seeking.

fn read_all(&mut self, buf: &mut Vec<u8>) -> Result<usize, StreamError>

Examples

    use iostream::io::*;

    let mut ms=MemoryStream::new();
    let data:[u8;1024]=[55;1024];
    ms.write_all(&data).unwrap();

    ms.set_position(0).unwrap();

    let mut p:Vec<u8>=Vec::new();
    ms.read_all(&mut p).unwrap();

    for i  in p {
    print!("{}",i);
    }

    println!();

    ms.set_position(0).unwrap();
    let mut p:Vec<u8>=vec![0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff];
    ms.read_all(&mut p).unwrap();

    for i  in p {
    print!("{}",i);
    }
    println!();

fn read(
    &mut self,
    buf: &mut [u8],
    offset: usize,
    count: usize
) -> Result<usize, StreamError>

Examples

    use iostream::io::*;
    let mut ms=MemoryStream::new();
    let data:[u8;1024]=[55;1024];
    ms.write_all(&data).unwrap();

    ms.set_position(0).unwrap();

    let mut data:Vec<u8>=vec![0;250];
    let len=data.len();
    let size = ms.read(&mut data, 0,len).unwrap();

fn read_byte(&mut self) -> Result<u8, StreamError>

Examples

   use iostream::io::*;

   let data:[u8;10]=[5;10];
   let mut ms= MemoryStream::new_to(&data);

   for s in 0..10 {
   let d=  ms.read_byte().unwrap();
   print!("{}",d);
   }

fn seek(
    &mut self,
    offset: i64,
    origin: SeekOrigin
) -> Result<u64, Box<dyn Error>>

sets the position within the current stream.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Box<dyn Error>>

Examples

use iostream::io::*;

let mut ms= MemoryStream::new();
let data: [u8; 1024] = [2; 1024];
ms.write_all(&data).unwrap();

fn write(
    &mut self,
    buf: &[u8],
    offset: usize,
    count: usize
) -> Result<usize, Box<dyn Error>>

Examples

use iostream::io::*;
let mut ms= MemoryStream::new();
let data2:[u8;100]=[2;100];
ms.write(&data2,50,50).unwrap();

fn flush(&mut self) -> Result<(), Box<dyn Error>>

clears all buffers for this stream and causes any buffered data to be written to the underlying device.

fn copy_to(&mut self, target: &mut dyn Stream) -> Result<(), Box<dyn Error>>

copy current stream to target stream # Examples ```rust use iostream::io::*; use std::fs::File;