Module std::io

Streams and other byte I/O functionality

Modules

Protocols

Structs

Functions

• fn take<R>(self: &mut R, limit: u64) -> TakeAdapter<R>

  R: Readable<R>

  source

  Returns an adapter for a stream that returns EOF after limit bytes have been read.

  Example

  use std::io::{SliceReader, take};
  use std::string::StringBuf;
  
  let reader = SliceReader::new("Hello, world!");
  
  let buf = StringBuf::new();
  defer buf.free();
  
  reader.take(5).read_to_end(&buf).unwrap();
  
  assert_eq!(buf[..] as &[u8], "Hello");
  Run this example

• fn chain<R1, R2>(self: &mut R1, other: &mut R2) -> ChainAdapter<R1, R2>

  R1: Readable<R1>

  R2: Readable<R2>

  source

  Chains the two streams together

  The resulting stream will first read all bytes from self, then all bytes from other.

  Example

  use std::io::{SliceReader, chain};
  use std::string::StringBuf;
  
  let reader1 = SliceReader::new("Hello, ");
  let reader2 = SliceReader::new("world!");
  
  let buf = StringBuf::new();
  defer buf.free();
  
  reader1.chain(&reader2).read_to_end(&buf).unwrap();
  
  assert_eq!(buf[..] as &[u8], "Hello, world!");
  Run this example

• fn copy<S, D>(src: &mut S, dst: &mut D) -> Result<u64>

  S: Readable<S>

  D: Writable<D>

  source

  Copy the entire stream src into dst

  Internally allocates a buffer with the size of DEFAULT_BUFFER_SIZE. If you want to use a custom buffer, use copy_using.

  Example

  use std::io::{copy, SliceReader, StringWriter};
  use std::string::StringBuf;
  
  let str = StringBuf::new();
  defer str.free();
  
  let writer = StringWriter::new(&str);
  let reader = SliceReader::new("Hello, world!");
  
  copy(&reader, &writer).unwrap();
  assert_eq!(str[..] as &[u8], "Hello, world!");
  Run this example

• fn copy_using<S, D>(src: &mut S, dst: &mut D, buffer: &mut [u8]) -> Result<u64>

  S: Readable<S>

  D: Writable<D>

  source

  Copy the entire stream src into dst using a provided buffer.

• fn read_byte<R>(reader: &mut R) -> Result<u8>

  R: Readable<R>

  source

  Reads a single byte from the stream.

  Returns Error::eof if the stream has no bytes left.

• fn read_until<R>(r: &mut R, delim: u8, buf: &mut StringBuf) -> Result<usize>

  R: BufferedReadable<R>

  source

  Reads the stream into buf until a specific byte is encountered.

  The delim terminator is included.

  Example

  use std::io::{SliceReader, read_until};
  use std::string::StringBuf;
  
  let stream = SliceReader::new("Hello\nWorld\n");
  let buf = StringBuf::new();
  defer buf.free();
  
  stream.read_until('\n', &buf).unwrap();
  assert_eq!(buf[..] as &[u8], "Hello\n");
  buf.clear();
  stream.read_until('\n', &buf).unwrap();
  assert_eq!(buf[..] as &[u8], "World\n");
  Run this example

• fn lines<R>(reader: &mut R) -> LineIterator<R>

  R: BufferedReadable<R>

  source

  Return an iterator that yields the stream's contents line by line.

  Both \n and \r\n are considered line terminators and they are omitted from the yielded lines.

  The iterator allocates a buffer of the line's contents, so it should be freed when it is no longer needed.

  Example

  use std::io::{SliceReader, lines};
  
  let stream = SliceReader::new("Hello\nWorld\n");
  let lines = stream.lines();
  defer lines.free();
  
  assert_eq!(lines.next(), Option::some(Result::ok("Hello")));
  assert_eq!(lines.next(), Option::some(Result::ok("World")));
  assert_eq!(lines.next(), Option::none());
  Run this example

Types

• type Result<T> = Result<T, Error>

  source

  Type alias for the result of I/O operations.

  See also Error and the main Result.

Enums

Macros

Consts

• const DEFAULT_BUFFER_SIZE: usize = ...

  source

  Default buffer size for I/O methods that allocate a buffer.

Statics

• static FMT_BUF: [u8; 256]

  source

  Buffer for formatted standard I/O.

  A single thread local buffer is used for convenience stdio formatting macros. This buffer has limited a purpose (if you need a larger buffer, use StdioStream directly). As many formatters write individual characters, doing a syscall for every one would be a performance killer.