Struct rhit::io::Stdout 1.0.0[−][src]
A handle to the global standard output stream of the current process.
Each handle shares a global buffer of data to be written to the standard
output stream. Access is also synchronized via a lock and explicit control
over locking is available via the lock
method.
Created by the io::stdout
method.
Note: Windows Portability Consideration
When operating in a console, the Windows implementation of this stream does not support non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return an error.
Implementations
impl Stdout
[src]
pub fn lock(&self) -> StdoutLock<'_>ⓘNotable traits for StdoutLock<'_>
impl<'_> Write for StdoutLock<'_>
[src]
Notable traits for StdoutLock<'_>
impl<'_> Write for StdoutLock<'_>
Locks this handle to the standard output stream, returning a writable guard.
The lock is released when the returned lock goes out of scope. The
returned guard also implements the Write
trait for writing data.
Examples
use std::io::{self, Write}; fn main() -> io::Result<()> { let stdout = io::stdout(); let mut handle = stdout.lock(); handle.write_all(b"hello world")?; Ok(()) }
Trait Implementations
impl AsRawFd for Stdout
1.21.0[src]
impl Debug for Stdout
1.16.0[src]
impl<'_> Write for &'_ Stdout
1.48.0[src]
pub fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]
pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
[src]
pub fn is_write_vectored(&self) -> bool
[src]
pub fn flush(&mut self) -> Result<(), Error>
[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, args: Arguments<'_>) -> Result<(), Error>
[src]
pub fn by_ref(&mut self) -> &mut Selfⓘ
[src]
impl Write for Stdout
[src]
pub fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]
pub fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
[src]
pub fn is_write_vectored(&self) -> bool
[src]
pub fn flush(&mut self) -> Result<(), Error>
[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, args: Arguments<'_>) -> Result<(), Error>
[src]
pub fn by_ref(&mut self) -> &mut Selfⓘ
[src]
Auto Trait Implementations
impl RefUnwindSafe for Stdout
[src]
impl Send for Stdout
[src]
impl Sync for Stdout
[src]
impl Unpin for Stdout
[src]
impl UnwindSafe for Stdout
[src]
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<S> IsTty for S where
S: AsRawFd,
[src]
S: AsRawFd,
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>,