Struct View 

pub struct View<T> {
    inner: T,
}

A wrapper for any kind of view.

Fields

inner: T

Implementations

impl<T> View<T>

pub fn new(inner: T) -> View<T>

Wraps the view.

pub fn into_inner(self) -> T

Unwraps the view, returning the inner type.

pub fn with_view_marker( self, view_marker: impl Into<Cow<'static, str>>, ) -> View<T>

Adds a view marker, which is used for hot-reloading and debug purposes.

Trait Implementations

impl<T> AddAnyAttr for View<T>

where T: AddAnyAttr,

type Output<SomeNewAttr: Attribute> = View<<T as AddAnyAttr>::Output<SomeNewAttr>>

The new type once the attribute has been added.

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

where NewAttr: Attribute, <View<T> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

impl<T> Clone for View<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for View<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<C> From<View<C>> for ViewFn

where C: Clone + Send + Sync + 'static, View<C>: IntoAny,

fn from(value: View<C>) -> ViewFn

Converts to this type from the input type.

impl<C> From<View<C>> for ViewFnOnce

where C: Send + Sync + 'static, View<C>: IntoAny,

fn from(value: View<C>) -> ViewFnOnce

Converts to this type from the input type.

impl<T> Hash for View<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Ord for View<T>

where T: Ord,

fn cmp(&self, other: &View<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for View<T>

where T: PartialEq,

fn eq(&self, other: &View<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialOrd for View<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &View<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Render for View<T>

where T: Render,

type State = <T as Render>::State

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

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

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

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

Updates the view with new data.

impl<T> RenderHtml for View<T>

where T: RenderHtml,

const MIN_LENGTH: usize = <T as RenderHtml>::MIN_LENGTH

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

const EXISTS: bool = <T as RenderHtml>::EXISTS

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

type AsyncOutput = <T as RenderHtml>::AsyncOutput

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

type Owned = View<<T as RenderHtml>::Owned>

An equivalent value that is 'static.

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

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

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.

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 View<T>: Sized,

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

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

Makes a set of DOM nodes rendered from HTML interactive.

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

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

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

Convert into the equivalent value that is 'static.

fn html_len(&self) -> usize

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

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.

impl<T> ToTemplate for View<T>

where T: ToTemplate,

fn to_template( buf: &mut String, class: &mut String, style: &mut String, inner_html: &mut String, position: &mut Position, )

Renders a view type to a template. This does not take actual view data, but can be used for constructing part of an HTML <template> that corresponds to a view of a particular type.

const TEMPLATE: &'static str = ""

The HTML content of the static template.

const CLASS: &'static str = ""

The class attribute content known at compile time.

const STYLE: &'static str = ""

The style attribute content known at compile time.

const LEN: usize = _

The length of the template.

fn to_template_attribute( buf: &mut String, class: &mut String, style: &mut String, inner_html: &mut String, position: &mut Position, )

Renders a view type to a template in attribute position.

impl<T> Eq for View<T>

where T: Eq,

impl<T> StructuralPartialEq for View<T>