Struct vertigo::router::Router

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

Router based on hash part of current location.

use vertigo::{dom, Computed, Value, DomNode};
use vertigo::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 ToString for Route {
    fn to_string(&self) -> String {
        match self {
            Self::Page1 => "/",
            Self::Page2 => "/page2",
            Self::NotFound => "/404",
        }.to_string()
    }
}

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 copy of the value.

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

Performs copy-assignment from source.

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

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

This method tests for self and other values to be equal, and is used by ==.

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

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

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