Struct rhit::io::LineWriter 1.0.0[−][src]
Wraps a writer and buffers output to it, flushing whenever a newline
(0x0a
, '\n'
) is detected.
The BufWriter
struct wraps a writer and buffers its output.
But it only does this batched write when it goes out of scope, or when the
internal buffer is full. Sometimes, you'd prefer to write each line as it's
completed, rather than the entire buffer at once. Enter LineWriter
. It
does exactly that.
Like BufWriter
, a LineWriter
’s buffer will also be flushed when the
LineWriter
goes out of scope or when its internal buffer is full.
If there's still a partial line in the buffer when the LineWriter
is
dropped, it will flush those contents.
Examples
We can use LineWriter
to write one line at a time, significantly
reducing the number of actual writes to the file.
use std::fs::{self, File}; use std::io::prelude::*; use std::io::LineWriter; fn main() -> std::io::Result<()> { let road_not_taken = b"I shall be telling this with a sigh Somewhere ages and ages hence: Two roads diverged in a wood, and I - I took the one less traveled by, And that has made all the difference."; let file = File::create("poem.txt")?; let mut file = LineWriter::new(file); file.write_all(b"I shall be telling this with a sigh")?; // No bytes are written until a newline is encountered (or // the internal buffer is filled). assert_eq!(fs::read_to_string("poem.txt")?, ""); file.write_all(b"\n")?; assert_eq!( fs::read_to_string("poem.txt")?, "I shall be telling this with a sigh\n", ); // Write the rest of the poem. file.write_all(b"Somewhere ages and ages hence: Two roads diverged in a wood, and I - I took the one less traveled by, And that has made all the difference.")?; // The last line of the poem doesn't end in a newline, so // we have to flush or drop the `LineWriter` to finish // writing. file.flush()?; // Confirm the whole poem was written. assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]); Ok(()) }
Implementations
impl<W> LineWriter<W> where
W: Write,
[src]
W: Write,
pub fn new(inner: W) -> LineWriter<W>ⓘNotable traits for LineWriter<W>
impl<W> Write for LineWriter<W> where
W: Write,
[src]
Notable traits for LineWriter<W>
impl<W> Write for LineWriter<W> where
W: Write,
Creates a new LineWriter
.
Examples
use std::fs::File; use std::io::LineWriter; fn main() -> std::io::Result<()> { let file = File::create("poem.txt")?; let file = LineWriter::new(file); Ok(()) }
pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W>ⓘNotable traits for LineWriter<W>
impl<W> Write for LineWriter<W> where
W: Write,
[src]
Notable traits for LineWriter<W>
impl<W> Write for LineWriter<W> where
W: Write,
Creates a new LineWriter
with a specified capacity for the internal
buffer.
Examples
use std::fs::File; use std::io::LineWriter; fn main() -> std::io::Result<()> { let file = File::create("poem.txt")?; let file = LineWriter::with_capacity(100, file); Ok(()) }
pub fn get_ref(&self) -> &Wⓘ
[src]
Gets a reference to the underlying writer.
Examples
use std::fs::File; use std::io::LineWriter; fn main() -> std::io::Result<()> { let file = File::create("poem.txt")?; let file = LineWriter::new(file); let reference = file.get_ref(); Ok(()) }
pub fn get_mut(&mut self) -> &mut Wⓘ
[src]
Gets a mutable reference to the underlying writer.
Caution must be taken when calling methods on the mutable reference returned as extra writes could corrupt the output stream.
Examples
use std::fs::File; use std::io::LineWriter; fn main() -> std::io::Result<()> { let file = File::create("poem.txt")?; let mut file = LineWriter::new(file); // we can use reference just like file let reference = file.get_mut(); Ok(()) }
pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>>
[src]
Unwraps this LineWriter
, returning the underlying writer.
The internal buffer is written out before returning the writer.
Errors
An Err
will be returned if an error occurs while flushing the buffer.
Examples
use std::fs::File; use std::io::LineWriter; fn main() -> std::io::Result<()> { let file = File::create("poem.txt")?; let writer: LineWriter<File> = LineWriter::new(file); let file: File = writer.into_inner()?; Ok(()) }
Trait Implementations
impl<W> Debug for LineWriter<W> where
W: Write + Debug,
[src]
W: Write + Debug,
impl<W> Write for LineWriter<W> where
W: Write,
[src]
W: Write,
pub fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]
pub fn flush(&mut self) -> Result<(), Error>
[src]
pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
[src]
pub fn is_write_vectored(&self) -> bool
[src]
pub fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
[src]
pub fn write_all_vectored(
&mut self,
bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>
[src]
&mut self,
bufs: &mut [IoSlice<'_>]
) -> Result<(), Error>
pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
[src]
pub fn by_ref(&mut self) -> &mut Selfⓘ
[src]
Auto Trait Implementations
impl<W> RefUnwindSafe for LineWriter<W> where
W: RefUnwindSafe,
[src]
W: RefUnwindSafe,
impl<W> Send for LineWriter<W> where
W: Send,
[src]
W: Send,
impl<W> Sync for LineWriter<W> where
W: Sync,
[src]
W: Sync,
impl<W> Unpin for LineWriter<W> where
W: Unpin,
[src]
W: Unpin,
impl<W> UnwindSafe for LineWriter<W> where
W: UnwindSafe,
[src]
W: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T, A> ExecutableCommand<A> for T where
T: Write,
A: Display,
[src]
T: Write,
A: Display,
pub fn execute(
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
[src]
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
Executes the given command directly.
The given command its ANSI escape code will be written and flushed onto Self
.
Arguments
-
The command that you want to execute directly.
Example
use std::io::{Write, stdout}; use crossterm::{Result, ExecutableCommand, style::Print}; fn main() -> Result<()> { // will be executed directly stdout() .execute(Print("sum:\n".to_string()))? .execute(Print(format!("1 + 1= {} ", 1 + 1)))?; Ok(()) // ==== Output ==== // sum: // 1 + 1 = 2 }
Have a look over at the Command API for more details.
Notes
- In the case of UNIX and Windows 10, ANSI codes are written to the given 'writer'.
- In case of Windows versions lower than 10, a direct WinApi call will be made.
The reason for this is that Windows versions lower than 10 do not support ANSI codes,
and can therefore not be written to the given
writer
. Therefore, there is no difference between execute and queue for those old Windows versions.
impl<T> From<T> for T
[src]
impl<T> Fun for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a Tⓘ
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut Tⓘ
pub unsafe fn drop(ptr: usize)
impl<T, A> QueueableCommand<A> for T where
T: Write,
A: Display,
[src]
T: Write,
A: Display,
pub fn queue(
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
[src]
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
Queues the given command for further execution.
Queued commands will be executed in the following cases:
- When
flush
is called manually on the given type implementingio::Write
. - The terminal will
flush
automatically if the buffer is full. - Each line is flushed in case of
stdout
, because it is line buffered.
Arguments
-
The command that you want to queue for later execution.
Examples
use std::io::{Write, stdout}; use crossterm::{Result, QueueableCommand, style::Print}; fn main() -> Result<()> { let mut stdout = stdout(); // `Print` will executed executed when `flush` is called. stdout .queue(Print("foo 1\n".to_string()))? .queue(Print("foo 2".to_string()))?; // some other code (no execution happening here) ... // when calling `flush` on `stdout`, all commands will be written to the stdout and therefore executed. stdout.flush()?; Ok(()) // ==== Output ==== // foo 1 // foo 2 }
Have a look over at the Command API for more details.
Notes
- In the case of UNIX and Windows 10, ANSI codes are written to the given 'writer'.
- In case of Windows versions lower than 10, a direct WinApi call will be made.
The reason for this is that Windows versions lower than 10 do not support ANSI codes,
and can therefore not be written to the given
writer
. Therefore, there is no difference between execute and queue for those old Windows versions.
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,