Struct mt_dom::patch::Patch

source ·

pub struct Patch<'a, Ns, Tag, Leaf, Att, Val>where
    Ns: PartialEq + Clone + Debug,
    Tag: PartialEq + Debug,
    Leaf: PartialEq + Clone + Debug,
    Att: PartialEq + Clone + Debug,
    Val: PartialEq + Clone + Debug,{
    pub tag: Option<&'a Tag>,
    pub patch_path: TreePath,
    pub patch_type: PatchType<'a, Ns, Tag, Leaf, Att, Val>,
}

Expand description

A Patch encodes an operation that modifies a real DOM element or native UI element

To update the real DOM that a user sees you’ll want to first diff your old virtual dom and new virtual dom.

This diff operation will generate Vec<Patch> with zero or more patches that, when applied to your real DOM, will make your real DOM look like your new virtual dom.

Each of the Patch contains TreePath which contains an array of indexes for each node that we need to traverse to get the target element.

Consider the following html:

<body>
    <main>
        <input type="text"/>
        <img src="pic.jpg"/>
    </main>
    <footer>
        <a>Link</a>
        <nav/>
    </footer>
</body>

The corresponding DOM tree would be

             .─.
            ( 0 )  <body>
             `-'
            /   \
           /     \
          /       \
         ▼         ▼
 <main> .─.         .─. <footer>
       ( 0 )       ( 1 )
        `-'         `-'
       /  \          | \ '.
      /    \         |  \  '.
     ▼      ▼        |   \   '.
   .─.      .─.      ▼    ▼     ▼
  ( 0 )    ( 1 )    .─.   .─.   .─.
   `─'      `─'    ( 0 ) ( 1 ) ( 2 )
 <input> <img>      `─'   `─'   `─'
                   <a>  <Text>   <nav>

To traverse to the <nav> element we follow the TreePath([0,1,2]). 0 - is the root element which is always zero. 1 - is the footer element since it is the 2nd element of the body. 2 - is the nav element since it is the 3rd node in the footer element.

Fields§

§tag: Option<&'a Tag>

the tag of the node at patch_path

§patch_path: TreePath

the path to traverse to get to the target element

§patch_type: PatchType<'a, Ns, Tag, Leaf, Att, Val>

the type of patch we are going to apply

Struct mt_dom::patch::Patch

Fields§

Implementations§

impl<'a, Ns, Tag, Leaf, Att, Val> Patch<'a, Ns, Tag, Leaf, Att, Val>where Ns: PartialEq + Clone + Debug, Tag: PartialEq + Debug, Leaf: PartialEq + Clone + Debug, Att: PartialEq + Clone + Debug, Val: PartialEq + Clone + Debug,

pub fn path(&self) -> &TreePath

pub fn tag(&self) -> Option<&Tag>

pub fn insert_before_node( tag: Option<&'a Tag>, patch_path: TreePath, nodes: Vec<&'a Node<Ns, Tag, Leaf, Att, Val>> ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

pub fn insert_after_node( tag: Option<&'a Tag>, patch_path: TreePath, nodes: Vec<&'a Node<Ns, Tag, Leaf, Att, Val>> ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

pub fn append_children( tag: &'a Tag, patch_path: TreePath, children: Vec<&'a Node<Ns, Tag, Leaf, Att, Val>> ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

pub fn remove_node( tag: Option<&'a Tag>, patch_path: TreePath ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

pub fn replace_node( tag: Option<&'a Tag>, patch_path: TreePath, replacement: Vec<&'a Node<Ns, Tag, Leaf, Att, Val>> ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

pub fn add_attributes( tag: &'a Tag, patch_path: TreePath, attrs: Vec<&'a Attribute<Ns, Att, Val>> ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

pub fn remove_attributes( tag: &'a Tag, patch_path: TreePath, attrs: Vec<&'a Attribute<Ns, Att, Val>> ) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

Trait Implementations§

impl<'a, Ns, Tag, Leaf, Att, Val> Clone for Patch<'a, Ns, Tag, Leaf, Att, Val>where Ns: PartialEq + Clone + Debug + Clone, Tag: PartialEq + Debug + Clone, Leaf: PartialEq + Clone + Debug + Clone, Att: PartialEq + Clone + Debug + Clone, Val: PartialEq + Clone + Debug + Clone,

fn clone(&self) -> Patch<'a, Ns, Tag, Leaf, Att, Val>

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

impl<'a, Ns, Tag, Leaf, Att, Val> Debug for Patch<'a, Ns, Tag, Leaf, Att, Val>where Ns: PartialEq + Clone + Debug + Debug, Tag: PartialEq + Debug + Debug, Leaf: PartialEq + Clone + Debug + Debug, Att: PartialEq + Clone + Debug + Debug, Val: PartialEq + Clone + Debug + Debug,

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

fn eq(&self, other: &Patch<'a, Ns, Tag, Leaf, Att, Val>) -> bool

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

impl<'a, Ns, Tag, Leaf, Att, Val> StructuralPartialEq for Patch<'a, Ns, Tag, Leaf, Att, Val>where Ns: PartialEq + Clone + Debug, Tag: PartialEq + Debug, Leaf: PartialEq + Clone + Debug, Att: PartialEq + Clone + Debug, Val: PartialEq + Clone + Debug,

Auto Trait Implementations§

impl<'a, Ns, Tag, Leaf, Att, Val> RefUnwindSafe for Patch<'a, Ns, Tag, Leaf, Att, Val>where Att: RefUnwindSafe, Leaf: RefUnwindSafe, Ns: RefUnwindSafe, Tag: RefUnwindSafe, Val: RefUnwindSafe,

impl<'a, Ns, Tag, Leaf, Att, Val> Send for Patch<'a, Ns, Tag, Leaf, Att, Val>where Att: Sync, Leaf: Sync, Ns: Sync, Tag: Sync, Val: Sync,

impl<'a, Ns, Tag, Leaf, Att, Val> Sync for Patch<'a, Ns, Tag, Leaf, Att, Val>where Att: Sync, Leaf: Sync, Ns: Sync, Tag: Sync, Val: Sync,

impl<'a, Ns, Tag, Leaf, Att, Val> Unpin for Patch<'a, Ns, Tag, Leaf, Att, Val>

impl<'a, Ns, Tag, Leaf, Att, Val> UnwindSafe for Patch<'a, Ns, Tag, Leaf, Att, Val>where Att: RefUnwindSafe, Leaf: RefUnwindSafe, Ns: RefUnwindSafe, Tag: RefUnwindSafe, Val: RefUnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>