Struct Router

pub struct Router<T: Clone + ToString + From<String> + PartialEq + 'static> {
    pub route: Computed<T>,
    /* private fields */
}

Router based on path or hash part of current location.

Note: If you want your app to support dynamic mount point, you should use method Driver::route_to_public which will always prefix your route with mount point.

use vertigo::{dom, DomNode, get_driver, router::Router};

#[derive(Clone, PartialEq, Debug)]
pub enum Route {
    Page1,
    Page2,
    NotFound,
}

impl Route {
    pub fn new(path: &str) -> Route {
        match path {
            "" | "/" | "/page1" => Self::Page1,
            "/page2" => Self::Page2,
            _ => Self::NotFound,
        }
    }
}

impl std::fmt::Display for Route {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let str = match self {
            Self::Page1 => "/",
            Self::Page2 => "/page2",
            Self::NotFound => "/404",
        };
        f.write_str(&get_driver().route_to_public(str))
    }
}

impl From<String> for Route {
    fn from(url: String) -> Self {
        Route::new(url.as_str())
    }
}

#[derive(Clone)]
pub struct State {
    route: Router<Route>,
}

impl State {
    pub fn component() -> DomNode {
        let route = Router::new_history_router();

        let state = State {
            route,
        };

        render(state)
    }
}

fn render(state: State) -> DomNode {
    dom! {
        <div>
            "..."
        </div>
    }
}

Fields

route: Computed<T>

Implementations

impl<T: Clone + ToString + From<String> + PartialEq + 'static> Router<T>

pub fn new_hash_router() -> Router<T>

Create new Router which sets route value upon hash change in browser bar. If callback is provided then it is fired instead.

pub fn new_history_router() -> Router<T>

Create new Router which sets route value upon url change (works with browser history)

pub fn set(&self, route: T)

Trait Implementations

impl<T: Clone + Clone + ToString + From<String> + PartialEq + 'static> Clone for Router<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + PartialEq + ToString + From<String>> Default for Router<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Clone + PartialEq + ToString + From<String>> EmbedDom for Router<T>

fn embed(self) -> DomNode

impl<T: PartialEq + Clone + ToString + From<String> + PartialEq + 'static> PartialEq for Router<T>

fn eq(&self, other: &Router<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: Clone + PartialEq + ToString + From<String>> Reactive<T> for Router<T>

fn set(&self, value: T)

fn get(&self, context: &Context) -> T

fn change(&self, change_fn: impl FnOnce(&mut T))

impl<T: Clone + PartialEq + ToString + From<String>> ToComputed<T> for Router<T>

fn to_computed(&self) -> Computed<T>

impl<T: Clone + ToString + From<String> + PartialEq + 'static> StructuralPartialEq for Router<T>