Skip to main content

Page

browser_commander::puppeteer::api

Struct Page 

Source 
pub struct Page { /* private fields */ }
Expand description

Puppeteer’s Page (puppeteer-core 25.12.0), a remote object served by browser-commander serve --stdio.

Extends EventEmitter; the inherited methods are repeated here.

Implementations§

Source§

impl Page

Source

pub async fn on( &self, type_: Value, handler: impl Into<JsFunction>, ) -> Result<Page, BridgeError>

EventEmitter.on

on<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler: Handler<EventsWithWildcard<Events>[Key]>): this
Source

pub async fn off( &self, type_: Value, handler: Option<JsFunction>, ) -> Result<Page, BridgeError>

EventEmitter.off

off<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler?: Handler<EventsWithWildcard<Events>[Key]>): this
Source

pub async fn emit( &self, type_: Value, event: Value, ) -> Result<bool, BridgeError>

EventEmitter.emit

emit<Key extends keyof EventsWithWildcard<Events>>(type: Key, event: EventsWithWildcard<Events>[Key]): boolean
Source

pub async fn once( &self, type_: Value, handler: impl Into<JsFunction>, ) -> Result<Page, BridgeError>

EventEmitter.once

once<Key extends keyof EventsWithWildcard<Events>>(type: Key, handler: Handler<EventsWithWildcard<Events>[Key]>): this
Source

pub async fn listener_count(&self, type_: Value) -> Result<f64, BridgeError>

EventEmitter.listenerCount

listenerCount(type: keyof EventsWithWildcard<Events>): number
Source

pub async fn remove_all_listeners( &self, type_: Option<Value>, ) -> Result<Page, BridgeError>

EventEmitter.removeAllListeners

removeAllListeners(type?: keyof EventsWithWildcard<Events>): this
Source

pub async fn is_service_worker_bypassed(&self) -> Result<bool, BridgeError>

Page.isServiceWorkerBypassed

isServiceWorkerBypassed(): boolean
Source

pub async fn is_drag_interception_enabled(&self) -> Result<bool, BridgeError>

Page.isDragInterceptionEnabled

isDragInterceptionEnabled(): boolean
Source

pub async fn is_java_script_enabled(&self) -> Result<bool, BridgeError>

Page.isJavaScriptEnabled

isJavaScriptEnabled(): boolean
Source

pub async fn wait_for_file_chooser( &self, options: Option<Value>, ) -> Result<FileChooser, BridgeError>

Page.waitForFileChooser

waitForFileChooser(options?: WaitTimeoutOptions): Promise<FileChooser>
Source

pub async fn set_geolocation(&self, options: Value) -> Result<(), BridgeError>

Page.setGeolocation

setGeolocation(options: GeolocationOptions): Promise<void>
Source

pub async fn target(&self) -> Result<Target, BridgeError>

Page.target

target(): Target
Source

pub async fn browser(&self) -> Result<Browser, BridgeError>

Page.browser

browser(): Browser
Source

pub async fn browser_context(&self) -> Result<BrowserContext, BridgeError>

Page.browserContext

browserContext(): BrowserContext
Source

pub async fn main_frame(&self) -> Result<Frame, BridgeError>

Page.mainFrame

mainFrame(): Frame
Source

pub async fn create_cdp_session(&self) -> Result<CDPSession, BridgeError>

Page.createCDPSession

createCDPSession(): Promise<CDPSession>
Source

pub async fn keyboard(&self) -> Result<Keyboard, BridgeError>

Page.keyboard

get keyboard(): Keyboard
Source

pub async fn touchscreen(&self) -> Result<Touchscreen, BridgeError>

Page.touchscreen

get touchscreen(): Touchscreen
Source

pub async fn coverage(&self) -> Result<Coverage, BridgeError>

Page.coverage

get coverage(): Coverage
Source

pub async fn tracing(&self) -> Result<Tracing, BridgeError>

Page.tracing

get tracing(): Tracing
Source

pub async fn webmcp(&self) -> Result<WebMCP, BridgeError>

Page.webmcp

get webmcp(): WebMCP
Source

pub async fn accessibility(&self) -> Result<Accessibility, BridgeError>

Page.accessibility

get accessibility(): Accessibility
Source

pub async fn frames(&self) -> Result<Vec<Frame>, BridgeError>

Page.frames

frames(): Frame[]
Source

pub async fn workers(&self) -> Result<Vec<WebWorker>, BridgeError>

Page.workers

workers(): WebWorker[]
Source

pub async fn set_request_interception( &self, value: bool, ) -> Result<(), BridgeError>

Page.setRequestInterception

setRequestInterception(value: boolean): Promise<void>
Source

pub async fn set_bypass_service_worker( &self, bypass: bool, ) -> Result<(), BridgeError>

Page.setBypassServiceWorker

setBypassServiceWorker(bypass: boolean): Promise<void>
Source

pub async fn set_drag_interception( &self, enabled: bool, ) -> Result<(), BridgeError>

Page.setDragInterception

setDragInterception(enabled: boolean): Promise<void>
Source

pub async fn set_offline_mode(&self, enabled: bool) -> Result<(), BridgeError>

Page.setOfflineMode

setOfflineMode(enabled: boolean): Promise<void>
Source

pub async fn emulate_network_conditions( &self, network_conditions: Option<Value>, ) -> Result<(), BridgeError>

Page.emulateNetworkConditions

emulateNetworkConditions(networkConditions: NetworkConditions | null): Promise<void>
Source

pub async fn set_default_navigation_timeout( &self, timeout: f64, ) -> Result<(), BridgeError>

Page.setDefaultNavigationTimeout

setDefaultNavigationTimeout(timeout: number): void
Source

pub async fn set_default_timeout(&self, timeout: f64) -> Result<(), BridgeError>

Page.setDefaultTimeout

setDefaultTimeout(timeout: number): void
Source

pub async fn get_default_timeout(&self) -> Result<f64, BridgeError>

Page.getDefaultTimeout

getDefaultTimeout(): number
Source

pub async fn get_default_navigation_timeout(&self) -> Result<f64, BridgeError>

Page.getDefaultNavigationTimeout

getDefaultNavigationTimeout(): number
Source

pub async fn locator( &self, selector: impl Into<JsFunction>, ) -> Result<Locator, BridgeError>

Page.locator

locator<Selector extends string>(selector: Selector): Locator<NodeFor<Selector>>
locator<Ret>(func: () => Awaitable<Ret>): Locator<Ret>
Source

pub async fn query_selector( &self, selector: &str, ) -> Result<Option<ElementHandle>, BridgeError>

Page.$

$<Selector extends string>(selector: Selector): Promise<ElementHandle<NodeFor<Selector>> | null>
Source

pub async fn query_selector_all( &self, selector: &str, options: Option<Value>, ) -> Result<Vec<ElementHandle>, BridgeError>

Page.$$

$$<Selector extends string>(selector: Selector, options?: QueryOptions): Promise<Array<ElementHandle<NodeFor<Selector>>>>
Source

pub async fn evaluate_handle( &self, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<JSHandle, BridgeError>

Page.evaluateHandle

evaluateHandle<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params ): Promise<HandleFor<Awaited<ReturnType<Func>>>>
Source

pub async fn query_objects( &self, prototype_handle: &JSHandle, ) -> Result<JSHandle, BridgeError>

Page.queryObjects

queryObjects<Prototype>(prototypeHandle: JSHandle<Prototype>): Promise<JSHandle<Prototype[]>>
Source

pub async fn eval_on_selector( &self, selector: &str, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Page.$eval

$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<NodeFor<Selector>, Params> = EvaluateFuncWith<NodeFor<Selector>, Params >>(selector: Selector, pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>
Source

pub async fn eval_on_selector_all( &self, selector: &str, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Page.$$eval

$$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<Array<NodeFor<Selector>>, Params> = EvaluateFuncWith<Array<NodeFor<Selector>>, Params>>(selector: Selector, pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>
Source

pub async fn cookies(&self, urls: &[&str]) -> Result<Vec<Value>, BridgeError>

Page.cookies

cookies(...urls: string[]): Promise<Cookie[]>

Page.deleteCookie

deleteCookie(...cookies: DeleteCookiesRequest[]): Promise<void>

Page.setCookie

setCookie(...cookies: CookieParam[]): Promise<void>
Source

pub async fn add_script_tag( &self, options: Value, ) -> Result<ElementHandle, BridgeError>

Page.addScriptTag

addScriptTag(options: FrameAddScriptTagOptions): Promise<ElementHandle<HTMLScriptElement>>
Source

pub async fn add_style_tag( &self, options: Value, ) -> Result<ElementHandle, BridgeError>

Page.addStyleTag

addStyleTag(options: Omit<FrameAddStyleTagOptions, 'url'>): Promise<ElementHandle<HTMLStyleElement>>
addStyleTag(options: FrameAddStyleTagOptions): Promise<ElementHandle<HTMLLinkElement>>
Source

pub async fn expose_function( &self, name: &str, pptr_function: Value, ) -> Result<(), BridgeError>

Page.exposeFunction

exposeFunction(name: string, pptrFunction: | Function | { default: Function; }): Promise<void>
Source

pub async fn remove_exposed_function( &self, name: &str, ) -> Result<(), BridgeError>

Page.removeExposedFunction

removeExposedFunction(name: string): Promise<void>
Source

pub async fn authenticate( &self, credentials: Option<Value>, ) -> Result<(), BridgeError>

Page.authenticate

authenticate(credentials: Credentials | null): Promise<void>
Source

pub async fn set_extra_http_headers( &self, headers: Value, ) -> Result<(), BridgeError>

Page.setExtraHTTPHeaders

setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>
Source

pub async fn set_user_agent( &self, user_agent: Value, user_agent_metadata: Option<Value>, ) -> Result<(), BridgeError>

Page.setUserAgent

setUserAgent(userAgent: string, userAgentMetadata?: Protocol.Emulation.UserAgentMetadata): Promise<void>
setUserAgent(options: { userAgent?: string; userAgentMetadata?: Protocol.Emulation.UserAgentMetadata; platform?: string; }): Promise<void>
Source

pub async fn metrics(&self) -> Result<Value, BridgeError>

Page.metrics

metrics(): Promise<Metrics>
Source

pub async fn capture_heap_snapshot( &self, options: Value, ) -> Result<(), BridgeError>

Page.captureHeapSnapshot

captureHeapSnapshot(options: HeapSnapshotOptions): Promise<void>
Source

pub async fn url(&self) -> Result<String, BridgeError>

Page.url

url(): string
Source

pub async fn content(&self) -> Result<String, BridgeError>

Page.content

content(): Promise<string>
Source

pub async fn set_content( &self, html: &str, options: Option<Value>, ) -> Result<(), BridgeError>

Page.setContent

setContent(html: string, options?: SetContentWaitForOptions): Promise<void>
Source

pub async fn goto( &self, url: &str, options: Option<Value>, ) -> Result<Option<HTTPResponse>, BridgeError>

Page.goto

goto(url: string, options?: GoToOptions): Promise<HTTPResponse | null>
Source

pub async fn reload( &self, options: Option<Value>, ) -> Result<Option<HTTPResponse>, BridgeError>

Page.reload

reload(options?: ReloadOptions): Promise<HTTPResponse | null>
Source

pub async fn wait_for_navigation( &self, options: Option<Value>, ) -> Result<Option<HTTPResponse>, BridgeError>

Page.waitForNavigation

waitForNavigation(options?: WaitForOptions): Promise<HTTPResponse | null>
Source

pub async fn wait_for_request( &self, url_or_predicate: impl Into<JsFunction>, options: Option<Value>, ) -> Result<HTTPRequest, BridgeError>

Page.waitForRequest

waitForRequest(urlOrPredicate: string | AwaitablePredicate<HTTPRequest>, options?: WaitTimeoutOptions): Promise<HTTPRequest>
Source

pub async fn wait_for_response( &self, url_or_predicate: impl Into<JsFunction>, options: Option<Value>, ) -> Result<HTTPResponse, BridgeError>

Page.waitForResponse

waitForResponse(urlOrPredicate: string | AwaitablePredicate<HTTPResponse>, options?: WaitTimeoutOptions): Promise<HTTPResponse>
Source

pub async fn wait_for_network_idle( &self, options: Option<Value>, ) -> Result<(), BridgeError>

Page.waitForNetworkIdle

waitForNetworkIdle(options?: WaitForNetworkIdleOptions): Promise<void>
Source

pub async fn wait_for_frame( &self, url_or_predicate: impl Into<JsFunction>, options: Option<Value>, ) -> Result<Frame, BridgeError>

Page.waitForFrame

waitForFrame(urlOrPredicate: string | ((frame: Frame) => Awaitable<boolean>), options?: WaitTimeoutOptions): Promise<Frame>
Source

pub async fn go_back( &self, options: Option<Value>, ) -> Result<Option<HTTPResponse>, BridgeError>

Page.goBack

goBack(options?: WaitForOptions): Promise<HTTPResponse | null>
Source

pub async fn go_forward( &self, options: Option<Value>, ) -> Result<Option<HTTPResponse>, BridgeError>

Page.goForward

goForward(options?: WaitForOptions): Promise<HTTPResponse | null>
Source

pub async fn bring_to_front(&self) -> Result<(), BridgeError>

Page.bringToFront

bringToFront(): Promise<void>
Source

pub async fn emulate(&self, device: Value) -> Result<(), BridgeError>

Page.emulate

emulate(device: Device): Promise<void>
Source

pub async fn set_java_script_enabled( &self, enabled: bool, ) -> Result<(), BridgeError>

Page.setJavaScriptEnabled

setJavaScriptEnabled(enabled: boolean): Promise<void>
Source

pub async fn set_bypass_csp(&self, enabled: bool) -> Result<(), BridgeError>

Page.setBypassCSP

setBypassCSP(enabled: boolean): Promise<void>
Source

pub async fn emulate_media_type( &self, type_: Option<&str>, ) -> Result<(), BridgeError>

Page.emulateMediaType

emulateMediaType(type?: string): Promise<void>
Source

pub async fn emulate_cpu_throttling( &self, factor: Option<f64>, ) -> Result<(), BridgeError>

Page.emulateCPUThrottling

emulateCPUThrottling(factor: number | null): Promise<void>
Source

pub async fn emulate_media_features( &self, features: Option<Vec<Value>>, ) -> Result<(), BridgeError>

Page.emulateMediaFeatures

emulateMediaFeatures(features?: MediaFeature[]): Promise<void>
Source

pub async fn emulate_locale( &self, locale: Option<&str>, ) -> Result<(), BridgeError>

Page.emulateLocale

emulateLocale(locale?: string): Promise<void>
Source

pub async fn emulate_timezone( &self, timezone_id: Option<&str>, ) -> Result<(), BridgeError>

Page.emulateTimezone

emulateTimezone(timezoneId?: string): Promise<void>
Source

pub async fn emulate_idle_state( &self, overrides: Option<Value>, ) -> Result<(), BridgeError>

Page.emulateIdleState

emulateIdleState(overrides?: { isUserActive: boolean; isScreenUnlocked: boolean; }): Promise<void>
Source

pub async fn emulate_vision_deficiency( &self, type_: Option<Value>, ) -> Result<(), BridgeError>

Page.emulateVisionDeficiency

emulateVisionDeficiency(type?: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest['type']): Promise<void>
Source

pub async fn set_viewport( &self, viewport: Option<Value>, ) -> Result<(), BridgeError>

Page.setViewport

setViewport(viewport: Viewport | null): Promise<void>
Source

pub async fn viewport(&self) -> Result<Option<Value>, BridgeError>

Page.viewport

viewport(): Viewport | null
Source

pub async fn evaluate( &self, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Page.evaluate

evaluate<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>
Source

pub async fn evaluate_on_new_document( &self, page_function: impl Into<JsFunction>, args: &[Value], ) -> Result<Value, BridgeError>

Page.evaluateOnNewDocument

evaluateOnNewDocument<Params extends unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown>(pageFunction: Func | string, ...args: Params ): Promise<NewDocumentScriptEvaluation>
Source

pub async fn remove_script_to_evaluate_on_new_document( &self, identifier: &str, ) -> Result<(), BridgeError>

Page.removeScriptToEvaluateOnNewDocument

removeScriptToEvaluateOnNewDocument(identifier: string): Promise<void>
Source

pub async fn set_cache_enabled( &self, enabled: Option<bool>, ) -> Result<(), BridgeError>

Page.setCacheEnabled

setCacheEnabled(enabled?: boolean): Promise<void>
Source

pub async fn screencast( &self, options: Option<Value>, ) -> Result<ScreenRecorder, BridgeError>

Page.screencast

screencast(options?: Readonly<ScreencastOptions>): Promise<ScreenRecorder>
Source

pub async fn record( &self, options: Option<Value>, ) -> Result<ScreenRecording, BridgeError>

Page.record

record(options?: Readonly<RecordOptions>): Promise<ScreenRecording>
Source

pub async fn screenshot( &self, options: Option<Value>, ) -> Result<Value, BridgeError>

Page.screenshot

screenshot(options: Readonly<ScreenshotOptions> & { encoding: 'base64'; }): Promise<string>
screenshot(options?: Readonly<ScreenshotOptions>): Promise<Uint8Array>
Source

pub async fn emulate_focused_page( &self, enabled: bool, ) -> Result<(), BridgeError>

Page.emulateFocusedPage

emulateFocusedPage(enabled: boolean): Promise<void>
Source

pub async fn create_pdf_stream( &self, options: Option<Value>, ) -> Result<Value, BridgeError>

Page.createPDFStream

createPDFStream(options?: PDFOptions): Promise<ReadableStream<Uint8Array>>
Source

pub async fn pdf(&self, options: Option<Value>) -> Result<Vec<u8>, BridgeError>

Page.pdf

pdf(options?: PDFOptions): Promise<Uint8Array>
Source

pub async fn title(&self) -> Result<String, BridgeError>

Page.title

title(): Promise<string>
Source

pub async fn close(&self, options: Option<Value>) -> Result<(), BridgeError>

Page.close

close(options?: {runBeforeUnload?: boolean}): Promise<void>
Source

pub async fn is_closed(&self) -> Result<bool, BridgeError>

Page.isClosed

isClosed(): boolean
Source

pub async fn mouse(&self) -> Result<Mouse, BridgeError>

Page.mouse

get mouse(): Mouse
Source

pub async fn click( &self, selector: &str, options: Option<Value>, ) -> Result<(), BridgeError>

Page.click

click(selector: string, options?: Readonly<ClickOptions>): Promise<void>
Source

pub async fn focus(&self, selector: &str) -> Result<(), BridgeError>

Page.focus

focus(selector: string): Promise<void>
Source

pub async fn hover(&self, selector: &str) -> Result<(), BridgeError>

Page.hover

hover(selector: string): Promise<void>
Source

pub async fn select( &self, selector: &str, values: &[&str], ) -> Result<Vec<String>, BridgeError>

Page.select

select(selector: string, ...values: string[]): Promise<string[]>
Source

pub async fn tap(&self, selector: &str) -> Result<(), BridgeError>

Page.tap

tap(selector: string): Promise<void>
Source

pub async fn type( &self, selector: &str, text: &str, options: Option<Value>, ) -> Result<(), BridgeError>

Page.type

type(selector: string, text: string, options?: Readonly<KeyboardTypeOptions>): Promise<void>
Source

pub async fn wait_for_selector( &self, selector: &str, options: Option<Value>, ) -> Result<Option<ElementHandle>, BridgeError>

Page.waitForSelector

waitForSelector<Selector extends string>(selector: Selector, options?: WaitForSelectorOptions): Promise<ElementHandle<NodeFor<Selector>> | null>
Source

pub async fn wait_for_function( &self, page_function: impl Into<JsFunction>, options: Option<Value>, args: &[Value], ) -> Result<JSHandle, BridgeError>

Page.waitForFunction

waitForFunction<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, options?: FrameWaitForFunctionOptions, ...args: Params ): Promise<HandleFor<Awaited<ReturnType<Func>>>>
Source

pub async fn wait_for_device_prompt( &self, options: Option<Value>, ) -> Result<DeviceRequestPrompt, BridgeError>

Page.waitForDevicePrompt

waitForDevicePrompt(options?: WaitTimeoutOptions): Promise<DeviceRequestPrompt>
Source§

impl Page

Source

pub async fn resize(&self, params: Value) -> Result<(), BridgeError>

Page.resize

resize(params: { contentWidth: number; contentHeight: number; }): Promise<void>
Source

pub async fn window_id(&self) -> Result<String, BridgeError>

Page.windowId

windowId(): Promise<WindowId>
Source

pub async fn open_dev_tools(&self) -> Result<Page, BridgeError>

Page.openDevTools

openDevTools(): Promise<Page>
Source

pub async fn has_dev_tools(&self) -> Result<bool, BridgeError>

Page.hasDevTools

hasDevTools(): Promise<boolean>
Source

pub async fn bluetooth(&self) -> Result<BluetoothEmulation, BridgeError>

Page.bluetooth

get bluetooth(): BluetoothEmulation
Source

pub async fn trigger_extension_action( &self, extension: &Extension, ) -> Result<(), BridgeError>

Page.triggerExtensionAction

triggerExtensionAction(extension: Extension): Promise<void>
Source

pub async fn extension_realms(&self) -> Result<Vec<Realm>, BridgeError>

Page.extensionRealms

extensionRealms(): Realm[]

Trait Implementations§

Source§

impl Clone for Page

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Page

Source§

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

Formats the value using the given formatter. Read more
Source§

impl FromWire for Page

Source§

fn from_wire(client: &BridgeClient, value: Value) -> Result<Self, BridgeError>

Convert, failing with BridgeError::Decode on a type mismatch.
Source§

impl PartialEq for Page

Source§

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

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=. Read more
Source§

impl Remote for Page

Source§

const TYPE: &'static str = "Page"

The Puppeteer type it wraps (Page).
Source§

fn from_remote(remote: RemoteHandle) -> Self

Wrap a handle without checking its type.
Source§

fn remote(&self) -> &RemoteHandle

The handle behind the wrapper.
Source§

fn cast<T: Remote>(&self) -> T

View the same object as another type, for example an ElementHandle as the JSHandle it extends.
Source§

impl StructuralPartialEq for Page

Auto Trait Implementations§

§

impl !RefUnwindSafe for Page

§

impl !UnwindSafe for Page

§

impl Freeze for Page

§

impl Send for Page

§

impl Sync for Page

§

impl Unpin for Page

§

impl UnsafeUnpin for Page

Blanket Implementations§

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> 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<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

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

Source§

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

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

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

Source§

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.
Source§

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.
Source§

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.
Source§

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.
Source§

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

Source§

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> ErasedDestructor for T
where T: 'static,

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

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

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

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
Source§

impl<T> MaybeSendSync for T

Source§

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

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
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
Source§

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

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

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.
Source§

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

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

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
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

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