Struct smoldot_light::platform::WithPrefix

pub struct WithPrefix<T> { /* private fields */ }

Implementation of a PlatformRef that wraps around another platform and adds a prefix before every log line and task name.

Implementations

impl<T> WithPrefix<T>

pub const fn new(prefix: String, inner: T) -> Self

Builds a new WithPrefix.

Trait Implementations

impl<T: Clone> Clone for WithPrefix<T>

fn clone(&self) -> WithPrefix<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for WithPrefix<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: PlatformRef> PlatformRef for WithPrefix<T>

type Delay = <T as PlatformRef>::Delay

Future that resolves once a certain amount of time has passed or a certain point in time is reached. See PlatformRef::sleep and PlatformRef::sleep_until.

type Instant = <T as PlatformRef>::Instant

A certain point in time. Typically std::time::Instant, but one can also use core::time::Duration.

type MultiStream = <T as PlatformRef>::MultiStream

A multi-stream connection.

type Stream = <T as PlatformRef>::Stream

Opaque object representing either a single-stream connection or a substream in a multi-stream connection.

type ReadWriteAccess<'a> = <T as PlatformRef>::ReadWriteAccess<'a>

Object that dereferences to read_write::ReadWrite and gives access to the stream’s buffers. See the read_write module for more information. See also PlatformRef::read_write_access.

type StreamErrorRef<'a> = <T as PlatformRef>::StreamErrorRef<'a>

Reference to an error that happened on a stream.

type StreamConnectFuture = <T as PlatformRef>::StreamConnectFuture

Future returned by PlatformRef::connect_stream.

type MultiStreamConnectFuture = <T as PlatformRef>::MultiStreamConnectFuture

Future returned by PlatformRef::connect_multistream.

type StreamUpdateFuture<'a> = <T as PlatformRef>::StreamUpdateFuture<'a>

Future returned by PlatformRef::wait_read_write_again.

type NextSubstreamFuture<'a> = <T as PlatformRef>::NextSubstreamFuture<'a>

Future returned by PlatformRef::next_substream.

fn now_from_unix_epoch(&self) -> Duration

Returns the time elapsed since the Unix Epoch (i.e. 00:00:00 UTC on 1 January 1970), ignoring leap seconds.

fn now(&self) -> Self::Instant

Returns an object that represents “now”.

fn fill_random_bytes(&self, buffer: &mut [u8])

The given buffer must be completely filled with pseudo-random bytes.

fn sleep(&self, duration: Duration) -> Self::Delay

Creates a future that becomes ready after at least the given duration has elapsed.

fn sleep_until(&self, when: Self::Instant) -> Self::Delay

Creates a future that becomes ready after the given instant has been reached.

fn spawn_task( &self, task_name: Cow<'_, str>, task: impl Future<Output = ()> + Send + 'static, )

Spawns a task that runs indefinitely in the background.

fn log<'a>( &self, log_level: LogLevel, log_target: &'a str, message: &'a str, key_values: impl Iterator<Item = (&'a str, &'a dyn Display)>, )

Emit a log line.

fn client_name(&self) -> Cow<'_, str>

Value returned when a JSON-RPC client requests the name of the client, or when a peer performs an identification request. Reasonable value is env!("CARGO_PKG_NAME").

fn client_version(&self) -> Cow<'_, str>

Value returned when a JSON-RPC client requests the version of the client, or when a peer performs an identification request. Reasonable value is env!("CARGO_PKG_VERSION").

fn supports_connection_type(&self, connection_type: ConnectionType) -> bool

Returns true if PlatformRef::connect_stream or PlatformRef::connect_multistream accepts a connection of the corresponding type.

fn connect_stream(&self, address: Address<'_>) -> Self::StreamConnectFuture

Starts a connection attempt to the given address.

fn connect_multistream( &self, address: MultiStreamAddress<'_>, ) -> Self::MultiStreamConnectFuture

Starts a connection attempt to the given address.

fn open_out_substream(&self, connection: &mut Self::MultiStream)

Queues the opening of an additional outbound substream.

fn next_substream<'a>( &self, connection: &'a mut Self::MultiStream, ) -> Self::NextSubstreamFuture<'a>

Waits until a new incoming substream arrives on the connection.

fn read_write_access<'a>( &self, stream: Pin<&'a mut Self::Stream>, ) -> Result<Self::ReadWriteAccess<'a>, Self::StreamErrorRef<'a>>

Returns an object that implements DerefMut<Target = ReadWrite>. The read_write::ReadWrite object allows the API user to read data from the stream and write data to the stream.

fn wait_read_write_again<'a>( &self, stream: Pin<&'a mut Self::Stream>, ) -> Self::StreamUpdateFuture<'a>

Returns a future that becomes ready when PlatformRef::read_write_access should be called again on this stream.