Struct AnyView

pub struct AnyView {
    type_id: TypeId,
    value: Erased,
    build: fn(Erased) -> AnyViewState,
    rebuild: fn(Erased, &mut AnyViewState),
    html_len: usize,
    to_html: fn(Erased, &mut String, &mut Position, bool, bool, Vec<AnyAttribute>),
    to_html_async: fn(Erased, &mut StreamBuilder, &mut Position, bool, bool, Vec<AnyAttribute>),
    to_html_async_ooo: fn(Erased, &mut StreamBuilder, &mut Position, bool, bool, Vec<AnyAttribute>),
    resolve: fn(Erased) -> Pin<Box<dyn Future<Output = AnyView> + Send>>,
    dry_resolve: fn(&mut Erased),
    hydrate_from_server: fn(Erased, &Cursor, &PositionState) -> AnyViewState,
    hydrate_async: fn(Erased, &Cursor, &PositionState) -> Pin<Box<dyn Future<Output = AnyViewState>>>,
}

A type-erased view. This can be used if control flow requires that multiple different types of view must be received, and it is either impossible or too cumbersome to use the EitherOf___ enums.

It can also be used to create recursive components, which otherwise cannot return themselves due to the static typing of the view tree.

Generally speaking, using AnyView restricts the amount of information available to the compiler and should be limited to situations in which it is necessary to preserve the maximum amount of type information possible.

Fields

type_id: TypeId

value: Erased

build: fn(Erased) -> AnyViewState

rebuild: fn(Erased, &mut AnyViewState)

html_len: usize

to_html: fn(Erased, &mut String, &mut Position, bool, bool, Vec<AnyAttribute>)

to_html_async: fn(Erased, &mut StreamBuilder, &mut Position, bool, bool, Vec<AnyAttribute>)

to_html_async_ooo: fn(Erased, &mut StreamBuilder, &mut Position, bool, bool, Vec<AnyAttribute>)

resolve: fn(Erased) -> Pin<Box<dyn Future<Output = AnyView> + Send>>

dry_resolve: fn(&mut Erased)

hydrate_from_server: fn(Erased, &Cursor, &PositionState) -> AnyViewState

hydrate_async: fn(Erased, &Cursor, &PositionState) -> Pin<Box<dyn Future<Output = AnyViewState>>>

Trait Implementations

impl AddAnyAttr for AnyView

type Output<SomeNewAttr: Attribute> = AnyViewWithAttrs

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <AnyView as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <AnyView as AddAnyAttr>::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

impl Debug for AnyView

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

Formats the value using the given formatter.

impl From<AnyView> for Fragment

fn from(view: AnyView) -> Fragment

Converts to this type from the input type.

impl From<Fragment> for AnyView

fn from(value: Fragment) -> AnyView

Converts to this type from the input type.

impl FromIterator<AnyView> for Fragment

fn from_iter<T>(iter: T) -> Fragment

where T: IntoIterator<Item = AnyView>,

Creates a value from an iterator.

impl IntoFragment for AnyView

fn into_fragment(self) -> Fragment

Converts some view into a type-erased collection of views.

impl Render for AnyView

type State = AnyViewState

The “view state” for this type, which can be retained between updates.

fn build(self) -> <AnyView as Render>::State

Creates the view for the first time, without hydrating from existing HTML.

fn rebuild(self, state: &mut <AnyView as Render>::State)

Updates the view with new data.

impl RenderHtml for AnyView

const MIN_LENGTH: usize = 0usize

The minimum length of HTML created when this view is rendered.

type AsyncOutput = AnyView

The type of the view after waiting for all asynchronous data to load.

type Owned = AnyView

An equivalent value that is 'static.

fn dry_resolve(&mut self)

“Runs” the view without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <AnyView as RenderHtml>::AsyncOutput

Waits for any asynchronous sections of the view to load and returns the output.

fn to_html_with_buf( self, buf: &mut String, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

Renders a view to HTML, writing it into the given buffer.

fn to_html_async_with_buf<const OUT_OF_ORDER: bool>( self, buf: &mut StreamBuilder, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

where AnyView: Sized,

Renders a view into a buffer of (synchronous or asynchronous) HTML chunks.

fn hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <AnyView as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

async fn hydrate_async( self, cursor: &Cursor, position: &PositionState, ) -> <AnyView as Render>::State

Asynchronously makes a set of DOM nodes rendered from HTML interactive.

fn html_len(&self) -> usize

An estimated length for this view, when rendered to HTML.

fn into_owned(self) -> <AnyView as RenderHtml>::Owned

Convert into the equivalent value that is 'static.

const EXISTS: bool = true

Whether this should actually exist in the DOM, if it is the child of an element.

fn to_html(self) -> String

where Self: Sized,

Renders a view to an HTML string.

fn to_html_branching(self) -> String

where Self: Sized,

Renders a view to HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_in_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML.

fn to_html_stream_in_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_out_of_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML.

fn to_html_stream_out_of_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn hydrate_from<const FROM_SERVER: bool>(self, el: &Element) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element.

fn hydrate_from_position<const FROM_SERVER: bool>( self, el: &Element, position: Position, ) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element and position.