rerun_bindings::python_bridge

Struct PyRecordingStream

Source 
struct PyRecordingStream(RecordingStream);

Tuple Fields§

§0: RecordingStream

Implementations§

Source§

impl PyRecordingStream

Source

fn is_forked_child(&self) -> bool

Determine if this stream is operating in the context of a forked child process.

This means the stream was created in the parent process. It now exists in the child process by way of fork, but it is effectively a zombie since its batcher and sink threads would not have been copied.

Calling operations such as flush or set_sink will result in an error.

Methods from Deref<Target = RecordingStream>§

pub fn clone_weak(&self) -> RecordingStream

Clones the [RecordingStream] without incrementing the refcount.

Useful e.g. if you want to make sure that a detached thread won’t prevent the [RecordingStream] from flushing during shutdown.

pub fn log<AS>( &self, ent_path: impl Into<EntityPath>, as_components: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Log data to Rerun.

This is the main entry point for logging data to rerun. It can be used to log anything that implements the AsComponents, such as any archetype or individual component.

The data will be timestamped automatically based on the [RecordingStream]’s internal clock. See [RecordingStream::set_time_sequence] etc for more information.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

See also: [Self::log_static] for logging static data.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

§Example:
ⓘ
rec.log(
    "my/points",
    &rerun::Points3D::new([(0.0, 0.0, 0.0), (1.0, 1.0, 1.0)]),
)?;

pub fn send_columns( &self, ent_path: impl Into<EntityPath>, indexes: impl IntoIterator<Item = TimeColumn>, columns: impl IntoIterator<Item = SerializedComponentColumn>, ) -> Result<(), RecordingStreamError>

Lower-level logging API to provide data spanning multiple timepoints.

Unlike the regular log API, which is row-oriented, this API lets you submit the data in a columnar form. The lengths of all of the TimeColumn and the component columns must match. All data that occurs at the same index across the different index/time and components arrays will act as a single logical row.

Note that this API ignores any stateful index/time set on the log stream via the [Self::set_time]/[Self::set_timepoint]/[Self::set_time_nanos]/etc. APIs. Furthermore, this will not inject the default timelines log_tick and log_time timeline columns.

pub fn log_static<AS>( &self, ent_path: impl Into<EntityPath>, as_components: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Log data to Rerun.

It can be used to log anything that implements the AsComponents, such as any archetype or individual component.

Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type. All timestamp data associated with this message will be dropped right before sending it to Rerun.

This is most often used for rerun::ViewCoordinates and rerun::AnnotationContext.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

See also [Self::log].

pub fn log_with_static<AS>( &self, ent_path: impl Into<EntityPath>, static_: bool, as_components: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Logs the contents of a component bundle into Rerun.

If static_ is set to true, all timestamp data associated with this message will be dropped right before sending it to Rerun. Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type.

Otherwise, the data will be timestamped automatically based on the [RecordingStream]’s internal clock. See RecordingStream::set_time_* family of methods for more information.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn log_serialized_batches( &self, ent_path: impl Into<EntityPath>, static_: bool, comp_batches: impl IntoIterator<Item = SerializedComponentBatch>, ) -> Result<(), RecordingStreamError>

Logs a set of SerializedComponentBatches into Rerun.

If static_ is set to true, all timestamp data associated with this message will be dropped right before sending it to Rerun. Static data has no time associated with it, exists on all timelines, and unconditionally shadows any temporal data of the same type.

Otherwise, the data will be timestamped automatically based on the [RecordingStream]’s internal clock. See RecordingStream::set_time_* family of methods for more information.

The number of instances will be determined by the longest batch in the bundle.

The entity path can either be a string (with special characters escaped, split on unescaped slashes) or an EntityPath constructed with crate::entity_path. See https://www.rerun.io/docs/concepts/entity-path for more on entity paths.

Internally, the stream will automatically micro-batch multiple log calls to optimize transport. See SDK Micro Batching for more information.

pub fn send_property<AS>( &self, name: impl Into<String>, values: &AS, ) -> Result<(), RecordingStreamError>
where AS: AsComponents + ?Sized,

Sends a property to the recording.

pub fn send_recording_name( &self, name: impl Into<String>, ) -> Result<(), RecordingStreamError>

Sends the name of the recording.

pub fn send_recording_start_time( &self, timestamp: impl Into<Timestamp>, ) -> Result<(), RecordingStreamError>

Sends the start time of the recording.

pub fn log_file_from_path( &self, filepath: impl AsRef<Path>, entity_path_prefix: Option<EntityPath>, static_: bool, ) -> Result<(), RecordingStreamError>

Logs the file at the given path using all re_data_loader::DataLoaders available.

A single path might be handled by more than one loader.

This method blocks until either at least one re_data_loader::DataLoader starts streaming data in or all of them fail.

See https://www.rerun.io/docs/reference/data-loaders/overview for more information.

pub fn log_file_from_contents( &self, filepath: impl AsRef<Path>, contents: Cow<'_, [u8]>, entity_path_prefix: Option<EntityPath>, static_: bool, ) -> Result<(), RecordingStreamError>

Logs the given contents using all re_data_loader::DataLoaders available.

A single path might be handled by more than one loader.

This method blocks until either at least one re_data_loader::DataLoader starts streaming data in or all of them fail.

See https://www.rerun.io/docs/reference/data-loaders/overview for more information.

pub fn is_enabled(&self) -> bool

Check if logging is enabled on this RecordingStream.

If not, all recording calls will be ignored.

pub fn store_info(&self) -> Option<StoreInfo>

The StoreInfo associated with this RecordingStream.

pub fn is_forked_child(&self) -> bool

Determine whether a fork has happened since creating this RecordingStream. In general, this means our batcher/sink threads are gone and all data logged since the fork has been dropped.

It is essential that [crate::cleanup_if_forked_child] be called after forking the process. SDK-implementations should do this during their initialization phase.

pub fn record_msg(&self, msg: LogMsg)

Records an arbitrary LogMsg.

pub fn record_row( &self, entity_path: EntityPath, row: PendingRow, inject_time: bool, )

Records a single PendingRow.

If inject_time is set to true, the row’s timestamp data will be overridden using the [RecordingStream]’s internal clock.

Internally, incoming PendingRows are automatically coalesced into larger Chunks to optimize for transport.

pub fn log_chunk(&self, chunk: Chunk)

Logs a single Chunk.

Will inject log_tick and log_time timeline columns into the chunk. If you don’t want to inject these, use [Self::send_chunk] instead.

pub fn log_chunks(&self, chunks: impl IntoIterator<Item = Chunk>)

Logs multiple Chunks.

This will not inject log_tick and log_time timeline columns into the chunk, for that use [Self::log_chunks].

pub fn send_chunk(&self, chunk: Chunk)

Records a single Chunk.

Will inject log_tick and log_time timeline columns into the chunk. If you don’t want to inject these, use [Self::send_chunks] instead.

pub fn send_chunks(&self, chunks: impl IntoIterator<Item = Chunk>)

Records multiple Chunks.

This will not inject log_tick and log_time timeline columns into the chunk, for that use [Self::log_chunks].

pub fn set_sink(&self, sink: Box<dyn LogSink>)

Swaps the underlying sink for a new one.

This guarantees that:

  1. all pending rows and chunks are batched, collected and sent down the current sink,
  2. the current sink is flushed if it has pending data in its buffers,
  3. the current sink’s backlog, if there’s any, is forwarded to the new sink.

When this function returns, the calling thread is guaranteed that all future record calls will end up in the new sink.

§Data loss

If the current sink is in a broken state (e.g. a gRPC sink with a broken connection that cannot be repaired), all pending data in its buffers will be dropped.

pub fn flush_async(&self)

Initiates a flush of the pipeline and returns immediately.

This does not wait for the flush to propagate (see [Self::flush_blocking]). See [RecordingStream] docs for ordering semantics and multithreading guarantees.

pub fn flush_blocking(&self)

Initiates a flush the batching pipeline and waits for it to propagate.

See [RecordingStream] docs for ordering semantics and multithreading guarantees.

pub fn connect_grpc(&self) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a [crate::log_sink::GrpcSink] sink pre-configured to use the specified address.

See also [Self::connect_grpc_opts] if you wish to configure the connection.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn connect_grpc_opts( &self, url: impl Into<String>, flush_timeout: Option<Duration>, ) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a [crate::log_sink::GrpcSink] sink pre-configured to use the specified address.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

flush_timeout is the minimum time the [GrpcSink][crate::log_sink::GrpcSink] will wait during a flush before potentially dropping data. Note: Passing None here can cause a call to flush to block indefinitely if a connection cannot be established.

pub fn serve_grpc( &self, server_memory_limit: MemoryLimit, ) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a [crate::grpc_server::GrpcServerSink] pre-configured to listen on rerun+http://127.0.0.1:9876/proxy.

To configure the gRPC server’s IP and port, use [Self::serve_grpc_opts] instead.

You can connect a viewer to it with rerun --connect.

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_memory_limit argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

pub fn serve_grpc_opts( &self, bind_ip: impl AsRef<str>, port: u16, server_memory_limit: MemoryLimit, ) -> Result<(), RecordingStreamError>

Swaps the underlying sink for a [crate::grpc_server::GrpcServerSink] pre-configured to listen on rerun+http://{bind_ip}:{port}/proxy.

0.0.0.0 is a good default for bind_ip.

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_memory_limit argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

pub fn spawn(&self) -> Result<(), RecordingStreamError>

Spawns a new Rerun Viewer process from an executable available in PATH, then swaps the underlying sink for a [crate::log_sink::GrpcSink] sink pre-configured to send data to that new process.

If a Rerun Viewer is already listening on this port, the stream will be redirected to that viewer instead of starting a new one.

See also [Self::spawn_opts] if you wish to configure the behavior of thew Rerun process as well as the underlying connection.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn spawn_opts( &self, opts: &SpawnOptions, flush_timeout: Option<Duration>, ) -> Result<(), RecordingStreamError>

Spawns a new Rerun Viewer process from an executable available in PATH, then swaps the underlying sink for a [crate::log_sink::GrpcSink] sink pre-configured to send data to that new process.

If a Rerun Viewer is already listening on this port, the stream will be redirected to that viewer instead of starting a new one.

The behavior of the spawned Viewer can be configured via opts. If you’re fine with the default behavior, refer to the simpler [Self::spawn].

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

flush_timeout is the minimum time the [GrpcSink][crate::log_sink::GrpcSink] will wait during a flush before potentially dropping data. Note: Passing None here can cause a call to flush to block indefinitely if a connection cannot be established.

pub fn memory(&self) -> MemorySinkStorage

Swaps the underlying sink for a [crate::sink::MemorySink] sink and returns the associated [MemorySinkStorage].

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn binary_stream(&self) -> BinaryStreamStorage

Swaps the underlying sink for a [crate::sink::BinaryStreamSink] sink and returns the associated [BinaryStreamStorage].

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn save(&self, path: impl Into<PathBuf>) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink at the specified path.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn save_opts(&self, path: impl Into<PathBuf>) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink at the specified path.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

If a blueprint was provided, it will be stored first in the file. Blueprints are currently an experimental part of the Rust SDK.

pub fn stdout(&self) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink pointed at stdout.

If there isn’t any listener at the other end of the pipe, the [RecordingStream] will default back to buffered mode, in order not to break the user’s terminal.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn stdout_opts(&self) -> Result<(), FileSinkError>

Swaps the underlying sink for a crate::sink::FileSink pointed at stdout.

If there isn’t any listener at the other end of the pipe, the [RecordingStream] will default back to buffered mode, in order not to break the user’s terminal.

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

If a blueprint was provided, it will be stored first in the file. Blueprints are currently an experimental part of the Rust SDK.

pub fn disconnect(&self)

Swaps the underlying sink for a [crate::sink::BufferedSink].

This is a convenience wrapper for [Self::set_sink] that upholds the same guarantees in terms of data durability and ordering. See [Self::set_sink] for more information.

pub fn send_blueprint( &self, blueprint: Vec<LogMsg>, activation_cmd: BlueprintActivationCommand, )

Send a blueprint through this recording stream

pub fn now(&self) -> TimePoint

Returns the current time of the recording on the current thread.

pub fn set_timepoint(&self, timepoint: impl Into<TimePoint>)

Set the current time of the recording, for the current calling thread.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

  • [Self::set_time]
  • [Self::set_time_sequence]
  • [Self::set_duration_secs]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn set_time( &self, timeline: impl Into<TimelineName>, value: impl TryInto<TimeCell>, )

Set the current value of one of the timelines.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

There is no requirement of monotonicity. You can move the time backwards if you like.

Example:

rec.set_time("frame_nr", rerun::TimeCell::from_sequence(42));
rec.set_time("duration", std::time::Duration::from_millis(123));
rec.set_time("capture_time", std::time::SystemTime::now());

See also:

  • [Self::set_timepoint]
  • [Self::set_time_sequence]
  • [Self::set_duration_secs]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn set_time_sequence( &self, timeline: impl Into<TimelineName>, sequence: impl Into<i64>, )

Set the current time of the recording, for the current calling thread.

Short for set_time(timeline, rerun::TimeCell::from_sequence(sequence)).

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_time_sequence("frame_nr", frame_nr). You can remove a timeline again using rec.disable_timeline("frame_nr").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

  • [Self::set_time]
  • [Self::set_timepoint]
  • [Self::set_duration_secs]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn set_duration_secs( &self, timeline: impl Into<TimelineName>, secs: impl Into<f64>, )

Set the current time of the recording, for the current calling thread.

Short for set_time(timeline, std::time::Duration::from_secs_f64(secs))..

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_duration_secs("time_since_start", time_offset). You can remove a timeline again using rec.disable_timeline("time_since_start").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

  • [Self::set_time]
  • [Self::set_timepoint]
  • [Self::set_timestamp_secs_since_epoch]
  • [Self::set_time_sequence]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn set_timestamp_secs_since_epoch( &self, timeline: impl Into<TimelineName>, secs: impl Into<f64>, )

Set a timestamp as seconds since Unix epoch (1970-01-01 00:00:00 UTC).

Short for self.set_time(timeline, rerun::TimeCell::from_timestamp_secs_since_epoch(secs)).

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_duration_secs("time_since_start", time_offset). You can remove a timeline again using rec.disable_timeline("time_since_start").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

  • [Self::set_time]
  • [Self::set_timepoint]
  • [Self::set_duration_secs]
  • [Self::set_time_sequence]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn set_time_secs( &self, timeline: impl Into<TimelineName>, seconds: impl Into<f64>, )

👎Deprecated since 0.23.0: Use either set_duration_secs or set_timestamp_secs_since_epoch instead

Set the current time of the recording, for the current calling thread.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_time_secs("sim_time", sim_time_secs). You can remove a timeline again using rec.disable_timeline("sim_time").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

  • [Self::set_timepoint]
  • [Self::set_time_sequence]
  • [Self::set_time_nanos]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn set_time_nanos( &self, timeline: impl Into<TimelineName>, nanos_since_epoch: impl Into<i64>, )

👎Deprecated since 0.23.0: Use set_time with either rerun::TimeCell::from_duration_nanos or rerun::TimeCell::from_timestamp_nanos_since_epoch, or with std::time::Duration or std::time::SystemTime.

Set the current time of the recording, for the current calling thread.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.set_time_nanos("sim_time", sim_time_nanos). You can remove a timeline again using rec.disable_timeline("sim_time").

There is no requirement of monotonicity. You can move the time backwards if you like.

See also:

  • [Self::set_timepoint]
  • [Self::set_time_sequence]
  • [Self::set_time_secs]
  • [Self::disable_timeline]
  • [Self::reset_time]

pub fn disable_timeline(&self, timeline: impl Into<TimelineName>)

Clears out the current time of the recording for the specified timeline, for the current calling thread.

For example: rec.disable_timeline("frame"), rec.disable_timeline("sim_time").

See also:

  • [Self::set_timepoint]
  • [Self::set_time_sequence]
  • [Self::set_time_secs]
  • [Self::set_time_nanos]
  • [Self::reset_time]

pub fn reset_time(&self)

Clears out the current time of the recording, for the current calling thread.

Used for all subsequent logging performed from this same thread, until the next call to one of the index/time setting methods.

For example: rec.reset_time().

See also:

  • [Self::set_timepoint]
  • [Self::set_time_sequence]
  • [Self::set_time_secs]
  • [Self::set_time_nanos]
  • [Self::disable_timeline]

Trait Implementations§

Source§

impl Clone for PyRecordingStream

Source§

fn clone(&self) -> PyRecordingStream

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Deref for PyRecordingStream

Source§

type Target = RecordingStream

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl IntoPy<Py<PyAny>> for PyRecordingStream

Source§

fn into_py(self, py: Python<'_>) -> PyObject

👎Deprecated since 0.23.0: IntoPy is going to be replaced by IntoPyObject. See the migration guide (https://pyo3.rs/v0.23.0/migration) for more information.
Performs the conversion.
Source§

impl<'py> IntoPyObject<'py> for PyRecordingStream

Source§

type Target = PyRecordingStream

The Python output type
Source§

type Output = Bound<'py, <PyRecordingStream as IntoPyObject<'py>>::Target>

The smart pointer type to use. Read more
Source§

type Error = PyErr

The type returned in the event of a conversion error.
Source§

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.
Source§

impl PyClass for PyRecordingStream

Source§

type Frozen = True

Whether the pyclass is frozen. Read more
Source§

impl PyClassImpl for PyRecordingStream

Source§

const IS_BASETYPE: bool = false

#[pyclass(subclass)]
Source§

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]
Source§

const IS_MAPPING: bool = false

#[pyclass(mapping)]
Source§

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]
Source§

type BaseType = PyAny

Base class
Source§

type ThreadChecker = SendablePyClass<PyRecordingStream>

This handles following two situations: Read more
Source§

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable
Source§

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.
Source§

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.
Source§

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.
Source§

fn items_iter() -> PyClassItemsIter

Source§

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc
Source§

fn lazy_type_object() -> &'static LazyTypeObject<Self>

§

fn dict_offset() -> Option<isize>

§

fn weaklist_offset() -> Option<isize>

Source§

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a PyRecordingStream

Source§

type Holder = Option<PyRef<'py, PyRecordingStream>>

Source§

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

Source§

impl PyMethods<PyRecordingStream> for PyClassImplCollector<PyRecordingStream>

Source§

fn py_methods(self) -> &'static PyClassItems

Source§

impl PyTypeInfo for PyRecordingStream

Source§

const NAME: &'static str = "PyRecordingStream"

Class name.
Source§

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.
Source§

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.
§

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.
§

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

👎Deprecated since 0.23.0: renamed to PyTypeInfo::type_object
Deprecated name for [PyTypeInfo::type_object].
§

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.
§

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_type_of
Deprecated name for [PyTypeInfo::is_type_of].
§

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.
§

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_exact_type_of
Deprecated name for [PyTypeInfo::is_exact_type_of].
Source§

impl DerefToPyAny for PyRecordingStream

Auto Trait Implementations§

Blanket Implementations§

§

impl<T> AlignerFor<1> for T

§

type Aligner = AlignTo1<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<1024> for T

§

type Aligner = AlignTo1024<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<128> for T

§

type Aligner = AlignTo128<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<16> for T

§

type Aligner = AlignTo16<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<16384> for T

§

type Aligner = AlignTo16384<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<2> for T

§

type Aligner = AlignTo2<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<2048> for T

§

type Aligner = AlignTo2048<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<256> for T

§

type Aligner = AlignTo256<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<32> for T

§

type Aligner = AlignTo32<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<32768> for T

§

type Aligner = AlignTo32768<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<4> for T

§

type Aligner = AlignTo4<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<4096> for T

§

type Aligner = AlignTo4096<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<512> for T

§

type Aligner = AlignTo512<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<64> for T

§

type Aligner = AlignTo64<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<8> for T

§

type Aligner = AlignTo8<T>

The AlignTo* type which aligns Self to ALIGNMENT.
§

impl<T> AlignerFor<8192> for T

§

type Aligner = AlignTo8192<T>

The AlignTo* type which aligns Self to ALIGNMENT.
Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Az for T

Source§

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

Casts the value.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

Source§

fn cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> CheckedAs for T

Source§

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

Source§

fn checked_cast_from(src: Src) -> Option<Dst>

Casts the value.
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FromPyObject<'_> for T
where T: PyClass + Clone,

§

fn extract_bound(obj: &Bound<'_, PyAny>) -> Result<T, PyErr>

Extracts Self from the bound smart pointer obj. Read more
§

impl<'py, T> FromPyObjectBound<'_, 'py> for T
where T: FromPyObject<'py>,

§

fn from_py_object_bound(ob: Borrowed<'_, 'py, PyAny>) -> Result<T, PyErr>

Extracts Self from the bound smart pointer obj. Read more
§

impl<T> FromRef<T> for T
where T: Clone,

§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<'py, T> IntoPyObjectExt<'py> for T
where T: IntoPyObject<'py>,

§

fn into_bound_py_any(self, py: Python<'py>) -> Result<Bound<'py, PyAny>, PyErr>

Converts self into an owned Python object, dropping type information.
§

fn into_py_any(self, py: Python<'py>) -> Result<Py<PyAny>, PyErr>

Converts self into an owned Python object, dropping type information and unbinding it from the 'py lifetime.
§

fn into_pyobject_or_pyerr(self, py: Python<'py>) -> Result<Self::Output, PyErr>

Converts self into a Python object. Read more
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<Src, Dst> LosslessTryInto<Dst> for Src
where Dst: LosslessTryFrom<Src>,

Source§

fn lossless_try_into(self) -> Option<Dst>

Performs the conversion.
Source§

impl<Src, Dst> LossyInto<Dst> for Src
where Dst: LossyFrom<Src>,

Source§

fn lossy_into(self) -> Dst

Performs the conversion.
Source§

impl<T> OverflowingAs for T

Source§

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

Source§

fn overflowing_cast_from(src: Src) -> (Dst, bool)

Casts the value.
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PyErrArguments for T
where T: for<'py> IntoPyObject<'py> + Send + Sync,

§

fn arguments(self, py: Python<'_>) -> Py<PyAny>

Arguments for exception
§

impl<T> PyTypeCheck for T
where T: PyTypeInfo,

§

const NAME: &'static str = <T as PyTypeInfo>::NAME

Name of self. This is used in error messages, for example.
§

fn type_check(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of Self, which may include a subtype. Read more
§

impl<'a, T> RCowCompatibleRef<'a> for T
where T: Clone + 'a,

§

type RefC = &'a T

The (preferably) ffi-safe equivalent of &Self.
§

type ROwned = T

The owned version of Self::RefC.
§

fn as_c_ref(from: &'a T) -> <T as RCowCompatibleRef<'a>>::RefC

Converts a reference to an FFI-safe type
§

fn as_rust_ref(from: <T as RCowCompatibleRef<'a>>::RefC) -> &'a T

Converts an FFI-safe type to a reference
§

impl<S> ROExtAcc for S

§

fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F

Gets a reference to a field, determined by offset. Read more
§

fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F

Gets a muatble reference to a field, determined by offset. Read more
§

fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F

Gets a const pointer to a field, the field is determined by offset. Read more
§

fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F

Gets a mutable pointer to a field, determined by offset. Read more
§

impl<S> ROExtOps<Aligned> for S

§

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more
§

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Aligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more
§

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more
§

impl<S> ROExtOps<Unaligned> for S

§

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more
§

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more
§

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> SaturatingAs for T

Source§

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,

Source§

fn saturating_cast_from(src: Src) -> Dst

Casts the value.
§

impl<T> SelfOps for T
where T: ?Sized,

§

fn eq_id(&self, other: &Self) -> bool

Compares the address of self with the address of other. Read more
§

fn piped<F, U>(self, f: F) -> U
where F: FnOnce(Self) -> U, Self: Sized,

Emulates the pipeline operator, allowing method syntax in more places. Read more
§

fn piped_ref<'a, F, U>(&'a self, f: F) -> U
where F: FnOnce(&'a Self) -> U,

The same as piped except that the function takes &Self Useful for functions that take &Self instead of Self. Read more
§

fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U
where F: FnOnce(&'a mut Self) -> U,

The same as piped, except that the function takes &mut Self. Useful for functions that take &mut Self instead of Self.
§

fn mutated<F>(self, f: F) -> Self
where F: FnOnce(&mut Self), Self: Sized,

Mutates self using a closure taking self by mutable reference, passing it along the method chain. Read more
§

fn observe<F>(self, f: F) -> Self
where F: FnOnce(&Self), Self: Sized,

Observes the value of self, passing it along unmodified. Useful in long method chains. Read more
§

fn into_<T>(self) -> T
where Self: Into<T>,

Performs a conversion with Into. using the turbofish .into_::<_>() syntax. Read more
§

fn as_ref_<T>(&self) -> &T
where Self: AsRef<T>, T: ?Sized,

Performs a reference to reference conversion with AsRef, using the turbofish .as_ref_::<_>() syntax. Read more
§

fn as_mut_<T>(&mut self) -> &mut T
where Self: AsMut<T>, T: ?Sized,

Performs a mutable reference to mutable reference conversion with AsMut, using the turbofish .as_mut_::<_>() syntax. Read more
§

fn drop_(self)
where Self: Sized,

Drops self using method notation. Alternative to std::mem::drop. Read more
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> To for T
where T: ?Sized,

§

fn to<T>(self) -> T
where Self: Into<T>,

Converts to T by calling Into<T>::into.
§

fn try_to<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Tries to convert to T by calling TryInto<T>::try_into.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<This> TransmuteElement for This
where This: ?Sized,

§

unsafe fn transmute_element<T>(self) -> Self::TransmutedPtr
where Self: CanTransmuteElement<T>,

Transmutes the element type of this pointer.. Read more
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> TypeIdentity for T
where T: ?Sized,

§

type Type = T

This is always Self.
§

fn into_type(self) -> Self::Type
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.
§

fn as_type(&self) -> &Self::Type

Converts a reference back to the original type.
§

fn as_type_mut(&mut self) -> &mut Self::Type

Converts a mutable reference back to the original type.
§

fn into_type_box(self: Box<Self>) -> Box<Self::Type>

Converts a box back to the original type.
§

fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>

Converts an Arc back to the original type. Read more
§

fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>

Converts an Rc back to the original type. Read more
§

fn from_type(this: Self::Type) -> Self
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.
§

fn from_type_ref(this: &Self::Type) -> &Self

Converts a reference back to the original type.
§

fn from_type_mut(this: &mut Self::Type) -> &mut Self

Converts a mutable reference back to the original type.
§

fn from_type_box(this: Box<Self::Type>) -> Box<Self>

Converts a box back to the original type.
§

fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self>

Converts an Arc back to the original type.
§

fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self>

Converts an Rc back to the original type.
Source§

impl<T> UnwrappedAs for T

Source§

fn unwrapped_as<Dst>(self) -> Dst
where T: UnwrappedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst
where Src: UnwrappedCast<Dst>,

Source§

fn unwrapped_cast_from(src: Src) -> Dst

Casts the value.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
Source§

impl<T> WrappingAs for T

Source§

fn wrapping_as<Dst>(self) -> Dst
where T: WrappingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> WrappingCastFrom<Src> for Dst
where Src: WrappingCast<Dst>,

Source§

fn wrapping_cast_from(src: Src) -> Dst

Casts the value.
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> Ungil for T
where T: Send,