Enum Oco

pub enum Oco<'a, T>
where
    T: ToOwned + 'a + ?Sized,
{
    Borrowed(&'a T),
    Counted(Arc<T>),
    Owned(<T as ToOwned>::Owned),
}

“Owned Clones Once”: a smart pointer that can be either a reference, an owned value, or a reference-counted pointer. This is useful for storing immutable values, such as strings, in a way that is cheap to clone and pass around.

The cost of the Clone implementation depends on the branch. Cloning the Oco::Borrowed variant simply copies the references (O(1)). Cloning the Oco::Counted variant increments a reference count (O(1)). Cloning the Oco::Owned variant requires an O(n) clone of the data.

For an amortized O(1) clone, you can use Oco::clone_inplace(). Using this method, Oco::Borrowed and Oco::Counted are still O(1). Oco::Owned does a single O(n) clone, but converts the object to the Oco::Counted branch, which means future clones will be O(1).

In general, you’ll either want to call clone_inplace() once, before sharing the Oco with other parts of your application (so that all future clones are O(1)), or simply use this as if it is a Cow with an additional branch for reference-counted values.

Variants

Borrowed(&'a T)

A static reference to a value.

Counted(Arc<T>)

A reference counted pointer to a value.

Owned(<T as ToOwned>::Owned)

An owned value.

Implementations

impl<T> Oco<'_, T>

where T: ToOwned + ?Sized,

pub fn into_owned(self) -> <T as ToOwned>::Owned

Converts the value into an owned value.

pub const fn is_borrowed(&self) -> bool

Checks if the value is Oco::Borrowed.

Examples

assert!(Oco::<str>::Borrowed("Hello").is_borrowed());
assert!(!Oco::<str>::Counted(Arc::from("Hello")).is_borrowed());
assert!(!Oco::<str>::Owned("Hello".to_string()).is_borrowed());

pub const fn is_counted(&self) -> bool

Checks if the value is Oco::Counted.

Examples

assert!(Oco::<str>::Counted(Arc::from("Hello")).is_counted());
assert!(!Oco::<str>::Borrowed("Hello").is_counted());
assert!(!Oco::<str>::Owned("Hello".to_string()).is_counted());

pub const fn is_owned(&self) -> bool

Checks if the value is Oco::Owned.

Examples

assert!(Oco::<str>::Owned("Hello".to_string()).is_owned());
assert!(!Oco::<str>::Borrowed("Hello").is_owned());
assert!(!Oco::<str>::Counted(Arc::from("Hello")).is_owned());

impl Oco<'_, str>

pub fn as_str(&self) -> &str

Returns a &str slice of this Oco.

Examples

let oco = Oco::<str>::Borrowed("Hello");
let s: &str = oco.as_str();
assert_eq!(s, "Hello");

impl Oco<'_, CStr>

pub fn as_c_str(&self) -> &CStr

Returns a &CStr slice of this Oco.

Examples

use std::ffi::CStr;

let oco =
    Oco::<CStr>::Borrowed(CStr::from_bytes_with_nul(b"Hello\0").unwrap());
let s: &CStr = oco.as_c_str();
assert_eq!(s, CStr::from_bytes_with_nul(b"Hello\0").unwrap());

impl Oco<'_, OsStr>

pub fn as_os_str(&self) -> &OsStr

Returns a &OsStr slice of this Oco.

Examples

use std::ffi::OsStr;

let oco = Oco::<OsStr>::Borrowed(OsStr::new("Hello"));
let s: &OsStr = oco.as_os_str();
assert_eq!(s, OsStr::new("Hello"));

impl Oco<'_, Path>

pub fn as_path(&self) -> &Path

Returns a &Path slice of this Oco.

Examples

use std::path::Path;

let oco = Oco::<Path>::Borrowed(Path::new("Hello"));
let s: &Path = oco.as_path();
assert_eq!(s, Path::new("Hello"));

impl<T> Oco<'_, [T]>

where [T]: ToOwned,

pub fn as_slice(&self) -> &[T]

Returns a &[T] slice of this Oco.

Examples

let oco = Oco::<[u8]>::Borrowed(b"Hello");
let s: &[u8] = oco.as_slice();
assert_eq!(s, b"Hello");

impl<'a, T> Oco<'a, T>

where T: ToOwned + 'a + ?Sized, Arc<T>: for<'b> From<&'b T>,

pub fn upgrade_inplace(&mut self)

Upgrades the value in place, by converting into Oco::Counted if it was previously Oco::Owned.

Examples

let mut oco1 = Oco::<str>::Owned("Hello".to_string());
assert!(oco1.is_owned());
oco1.upgrade_inplace();
assert!(oco1.is_counted());

pub fn clone_inplace(&mut self) -> Oco<'a, T>

Clones the value with inplace conversion into Oco::Counted if it was previously Oco::Owned.

Examples

let mut oco1 = Oco::<str>::Owned("Hello".to_string());
let oco2 = oco1.clone_inplace();
assert_eq!(oco1, oco2);
assert!(oco1.is_counted());
assert!(oco2.is_counted());

Trait Implementations

impl<'b> Add<&'b str> for Oco<'_, str>

type Output = Oco<'static, str>

The resulting type after applying the + operator.

fn add(self, rhs: &'b str) -> <Oco<'_, str> as Add<&'b str>>::Output

Performs the + operation.

impl<'b> Add<Cow<'b, str>> for Oco<'_, str>

type Output = Oco<'static, str>

The resulting type after applying the + operator.

fn add(self, rhs: Cow<'b, str>) -> <Oco<'_, str> as Add<Cow<'b, str>>>::Output

Performs the + operation.

impl<'b> Add<Oco<'b, str>> for Oco<'_, str>

type Output = Oco<'static, str>

The resulting type after applying the + operator.

fn add(self, rhs: Oco<'b, str>) -> <Oco<'_, str> as Add<Oco<'b, str>>>::Output

Performs the + operation.

impl<'a> AddAnyAttr for Oco<'static, str>

type Output<SomeNewAttr: Attribute> = Oco<'static, str>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <Oco<'static, str> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

Adds an attribute to the view.

impl AsRef<Path> for Oco<'_, OsStr>

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Path> for Oco<'_, str>

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<T> for Oco<'_, T>

where T: ToOwned + ?Sized,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl AttributeValue for Oco<'static, str>

type AsyncOutput = Oco<'static, str>

The type once all async data have loaded.

type State = (Element, Oco<'static, str>)

The state that should be retained between building and rebuilding.

type Cloneable = Oco<'static, str>

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.

type CloneableOwned = Oco<'static, str>

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> <Oco<'static, str> as AttributeValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build( self, el: &Element, key: &str, ) -> <Oco<'static, str> as AttributeValue>::State

Adds this attribute to the element during client-side rendering.

fn rebuild( self, key: &str, state: &mut <Oco<'static, str> as AttributeValue>::State, )

Applies a new value for the attribute.

fn into_cloneable(self) -> <Oco<'static, str> as AttributeValue>::Cloneable

Converts this attribute into an equivalent that can be cloned.

fn into_cloneable_owned( self, ) -> <Oco<'static, str> as AttributeValue>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

fn dry_resolve(&mut self)

“Runs” the attribute 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) -> <Oco<'static, str> as AttributeValue>::AsyncOutput

“Resolves” this into a form that is not waiting for any asynchronous data.

impl<T> Borrow<T> for Oco<'_, T>

where T: ToOwned + ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<'a, T> Clone for Oco<'a, T>

where T: ToOwned + 'a + ?Sized, Arc<T>: for<'b> From<&'b T>,

fn clone(&self) -> Oco<'a, T>

Returns a new Oco with the same value as this one. If the value is Oco::Owned, this will convert it into Oco::Counted, so that the next clone will be O(1).

Examples

String :

let oco = Oco::<str>::Owned("Hello".to_string());
let oco2 = oco.clone();
assert_eq!(oco, oco2);
assert!(oco2.is_counted());

Vec :

let oco = Oco::<[u8]>::Owned(b"Hello".to_vec());
let oco2 = oco.clone();
assert_eq!(oco, oco2);
assert!(oco2.is_counted());

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

Performs copy-assignment from source.

impl<T> Debug for Oco<'_, T>

where T: Debug + ToOwned + ?Sized,

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

Formats the value using the given formatter.

impl<T> Default for Oco<'_, T>

where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Default,

fn default() -> Oco<'_, T>

Returns the “default value” for a type.

impl<T> Deref for Oco<'_, T>

where T: ToOwned + ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, T> Deserialize<'a> for Oco<'static, T>

where T: ToOwned + 'a + ?Sized, <T as ToOwned>::Owned: DeserializeOwned,

fn deserialize<D>( deserializer: D, ) -> Result<Oco<'static, T>, <D as Deserializer<'a>>::Error>

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Oco<'_, T>

where T: Display + ToOwned + ?Sized,

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

Formats the value using the given formatter.

impl<'a, T, const N: usize> From<&'a [T; N]> for Oco<'a, [T]>

where [T]: ToOwned,

fn from(v: &'a [T; N]) -> Oco<'a, [T]>

Converts to this type from the input type.

impl<'a, T> From<&'a T> for Oco<'a, T>

where T: ToOwned + ?Sized,

fn from(v: &'a T) -> Oco<'a, T>

Converts to this type from the input type.

impl<T> From<Arc<T>> for Oco<'_, T>

where T: ToOwned + ?Sized,

fn from(v: Arc<T>) -> Oco<'_, T>

Converts to this type from the input type.

impl<T> From<Box<T>> for Oco<'_, T>

where T: ToOwned + ?Sized,

fn from(v: Box<T>) -> Oco<'_, T>

Converts to this type from the input type.

impl<'a, T> From<Cow<'a, T>> for Oco<'a, T>

where T: ToOwned + ?Sized,

fn from(v: Cow<'a, T>) -> Oco<'a, T>

Converts to this type from the input type.

impl From<Oco<'_, str>> for String

fn from(v: Oco<'_, str>) -> String

Converts to this type from the input type.

impl<'a, T> From<Oco<'a, T>> for Cow<'a, T>

where T: ToOwned + ?Sized,

fn from(value: Oco<'a, T>) -> Cow<'a, T>

Converts to this type from the input type.

impl<'a> From<Oco<'a, str>> for Oco<'a, [u8]>

fn from(v: Oco<'a, str>) -> Oco<'a, [u8]>

Converts to this type from the input type.

impl From<Oco<'static, str>> for TextProp

fn from(s: Oco<'static, str>) -> TextProp

Converts to this type from the input type.

impl From<String> for Oco<'_, str>

fn from(v: String) -> Oco<'_, str>

Converts to this type from the input type.

impl<T> From<Vec<T>> for Oco<'_, [T]>

where [T]: ToOwned<Owned = Vec<T>>,

fn from(v: Vec<T>) -> Oco<'_, [T]>

Converts to this type from the input type.

impl<'a> FromIterator<Oco<'a, str>> for String

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

where T: IntoIterator<Item = Oco<'a, str>>,

Creates a value from an iterator.

impl<T> Hash for Oco<'_, T>

where T: Hash + ToOwned + ?Sized,

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 IntoClass for Oco<'static, str>

type AsyncOutput = Oco<'static, str>

The type after all async data have resolved.

type State = (Element, Oco<'static, str>)

The view state retained between building and rebuilding.

type Cloneable = Oco<'static, str>

An equivalent value that can be cloned.

type CloneableOwned = Oco<'static, str>

An equivalent value that can be cloned and is 'static.

fn html_len(&self) -> usize

The estimated length of the HTML.

fn to_html(self, class: &mut String)

Renders the class to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Oco<'static, str> as IntoClass>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <Oco<'static, str> as IntoClass>::State

Adds this class to the element during client-side rendering.

fn rebuild(self, state: &mut <Oco<'static, str> as IntoClass>::State)

Updates the value.

fn into_cloneable(self) -> <Oco<'static, str> as IntoClass>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned( self, ) -> <Oco<'static, str> as IntoClass>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute 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) -> <Oco<'static, str> as IntoClass>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

fn reset(state: &mut <Oco<'static, str> as IntoClass>::State)

Reset the class list to the state before this class was added.

const TEMPLATE: &'static str = ""

The HTML that should be included in a <template>.

const MIN_LENGTH: usize = _

The minimum length of the HTML.

fn to_template(class: &mut String)

Renders the class to HTML for a <template>.

impl IntoStyle for Oco<'static, str>

type AsyncOutput = Oco<'static, str>

The type after all async data have resolved.

type State = (Element, Oco<'static, str>)

The view state retained between building and rebuilding.

type Cloneable = Oco<'static, str>

An equivalent value that can be cloned.

type CloneableOwned = Oco<'static, str>

An equivalent value that can be cloned and is 'static.

fn to_html(self, style: &mut String)

Renders the style to HTML.

fn hydrate<const FROM_SERVER: bool>( self, el: &Element, ) -> <Oco<'static, str> as IntoStyle>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element) -> <Oco<'static, str> as IntoStyle>::State

Adds this style to the element during client-side rendering.

fn rebuild(self, state: &mut <Oco<'static, str> as IntoStyle>::State)

Updates the value.

fn into_cloneable(self) -> <Oco<'static, str> as IntoStyle>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned( self, ) -> <Oco<'static, str> as IntoStyle>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute 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) -> <Oco<'static, str> as IntoStyle>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

fn reset(state: &mut <Oco<'static, str> as IntoStyle>::State)

Reset the styling to the state before this style was added.

impl IntoStyleValue for Oco<'static, str>

type AsyncOutput = Oco<'static, str>

The type after all async data have resolved.

type State = Oco<'static, str>

The view state retained between building and rebuilding.

type Cloneable = Oco<'static, str>

An equivalent value that can be cloned.

type CloneableOwned = Oco<'static, str>

An equivalent value that can be cloned and is 'static.

fn to_html(self, name: &str, style: &mut String)

Renders the style to HTML.

fn build( self, style: &CssStyleDeclaration, name: &str, ) -> <Oco<'static, str> as IntoStyleValue>::State

Adds this style to the element during client-side rendering.

fn rebuild( self, style: &CssStyleDeclaration, name: &str, state: &mut <Oco<'static, str> as IntoStyleValue>::State, )

Updates the value.

fn hydrate( self, _style: &CssStyleDeclaration, _name: &str, ) -> <Oco<'static, str> as IntoStyleValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn into_cloneable(self) -> <Oco<'static, str> as IntoStyleValue>::Cloneable

Converts this to a cloneable type.

fn into_cloneable_owned( self, ) -> <Oco<'static, str> as IntoStyleValue>::CloneableOwned

Converts this to a cloneable, owned type.

fn dry_resolve(&mut self)

“Runs” the attribute 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) -> <Oco<'static, str> as IntoStyleValue>::AsyncOutput

“Resolves” this into a type that is not waiting for any asynchronous data.

impl<T> Ord for Oco<'_, T>

where T: Ord + ToOwned + ?Sized,

fn cmp(&self, other: &Oco<'_, 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<'a, 'b, T> PartialEq<&'b [T]> for Oco<'a, [T]>

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &&'b [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<'a, 'b> PartialEq<&'b str> for Oco<'a, str>

fn eq(&self, other: &&'b str) -> 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> PartialEq<[T]> for Oco<'_, [T]>

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &[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<'a, 'b, T> PartialEq<Cow<'b, [T]>> for Oco<'a, [T]>

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &Cow<'b, [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<'a, 'b> PartialEq<Cow<'b, str>> for Oco<'a, str>

fn eq(&self, other: &Cow<'b, str>) -> 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> PartialEq<Oco<'_, [T]>> for [T]

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &Oco<'_, [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> PartialEq<Oco<'_, [T]>> for Vec<T>

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &Oco<'_, [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 PartialEq<Oco<'_, str>> for String

fn eq(&self, other: &Oco<'_, str>) -> 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 PartialEq<Oco<'_, str>> for str

fn eq(&self, other: &Oco<'_, str>) -> 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<'a, 'b, T> PartialEq<Oco<'a, [T]>> for &'b [T]

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &Oco<'a, [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<'a, 'b, T> PartialEq<Oco<'a, [T]>> for Cow<'b, [T]>

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &Oco<'a, [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<'a, 'b> PartialEq<Oco<'a, str>> for &'b str

fn eq(&self, other: &Oco<'a, str>) -> 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<'a, 'b> PartialEq<Oco<'a, str>> for Cow<'b, str>

fn eq(&self, other: &Oco<'a, str>) -> 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<'b, A, B> PartialEq<Oco<'b, B>> for Oco<'_, A>

where A: PartialEq<B> + ToOwned + ?Sized, B: ToOwned + ?Sized,

fn eq(&self, other: &Oco<'b, B>) -> 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 PartialEq<String> for Oco<'_, str>

fn eq(&self, other: &String) -> 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> PartialEq<Vec<T>> for Oco<'_, [T]>

where T: PartialEq, [T]: ToOwned,

fn eq(&self, other: &Vec<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 PartialEq<str> for Oco<'_, str>

fn eq(&self, other: &str) -> 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<'b, A, B> PartialOrd<Oco<'b, B>> for Oco<'_, A>

where A: PartialOrd<B> + ToOwned + ?Sized, B: ToOwned + ?Sized,

fn partial_cmp(&self, other: &Oco<'b, B>) -> 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 Render for Oco<'static, str>

type State = OcoStrState

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

fn build(self) -> <Oco<'static, str> as Render>::State

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

fn rebuild(self, state: &mut <Oco<'static, str> as Render>::State)

Updates the view with new data.

impl RenderHtml for Oco<'static, str>

const MIN_LENGTH: usize = 0usize

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

type AsyncOutput = Oco<'static, str>

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

type Owned = Oco<'static, str>

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) -> <Oco<'static, str> 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 hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <Oco<'static, str> as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

fn into_owned(self) -> <Oco<'static, str> 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 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 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 Self: Sized,

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

fn hydrate_async( self, cursor: &Cursor, position: &PositionState, ) -> impl Future<Output = Self::State>

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

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<'a, T> Serialize for Oco<'a, T>

where T: ToOwned + 'a + ?Sized, &'b T: for<'b> Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl ToHref for Oco<'_, str>

fn to_href(&self) -> Box<dyn Fn() -> String + '_>

Converts the (static or reactive) URL into a function that can be called to return the URL.

impl ToTemplate for Oco<'static, str>

const TEMPLATE: &'static str = <&str as ToTemplate>::TEMPLATE

The HTML content of the static template.

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 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 Oco<'_, T>

where T: ToOwned + Eq + ?Sized,