Package com.vaadin.flow.internal

Class StateNode

  • All Implemented Interfaces:
    Serializable
    public class StateNode
extends Object
implements Serializable
    A node in the state tree that is synchronized with the client-side. Data stored in nodes is structured into different features to provide isolation. The features available for a node are defined when the node is created.

    For internal use only. May be renamed or removed in a future release.

    Since:
    1.0
    Author:
    Vaadin Ltd
    See Also:
    StateTree, Serialized Form

    • Constructor Detail

      • StateNode

        @SafeVarargs
public StateNode​(Class<? extends NodeFeature>... featureTypes)
        Creates a state node with the given feature types.
        Parameters:
        featureTypes - a collection of feature classes that the node should support

      • StateNode

        public StateNode​(StateNode node)
        Create a new instance using the same features as provided node declares.
        Parameters:
        node - the node whose features set will be copied

      • StateNode

        @SafeVarargs
public StateNode​(List<Class<? extends NodeFeature>> reportableFeatureTypes,
                 Class<? extends NodeFeature>... additionalFeatureTypes)
        Creates a state node with the given feature types and required features that are always sent to the client side.
        Parameters:
        reportableFeatureTypes - the list of the features that are required on the client side (populated even if they are empty)
        additionalFeatureTypes - a collection of feature classes that the node should support. May, but is not required to, also include reportable feature types.

    • Method Detail

      • getOwner

        public NodeOwner getOwner()
        Gets the node owner that this node currently belongs to.
        Returns:
        the node owner

      • getParent

        public StateNode getParent()
        Gets the parent node that this node belongs to.
        Returns:
        the current parent node; null if the node is not attached to a parent node, or if this node is the root of a state tree.

      • setParent

        public void setParent​(StateNode parent)
        Sets the parent node that this node belongs to. This node is set to belong to the node owner of the parent node. The node still retains its owner when the parent is set to null.
        Parameters:
        parent - the new parent of this node; or null if this node is not attached to another node

      • onAttach

        protected void onAttach()
        Called when this node has been attached to a state tree.

      • forEachChild

        public void forEachChild​(Consumer<StateNode> action)
        Executes the given action for each child node of this state node.
        Parameters:
        action - the action to execute, not null

      • setTree

        protected void setTree​(StateTree tree)
        Sets the state tree that this node belongs to.
        Parameters:
        tree - the state tree

      • removeFromTree

        public void removeFromTree()
        Removes the node from its parent and unlinks the node (and children) from the state tree.

      • prepareForResync

        protected void prepareForResync()
        Prepares the tree below this node for resynchronization by detaching all descendants, setting their internal state to not yet attached, and calling the attach listeners.

      • getFeature

        public <T extends NodeFeature> T getFeature​(Class<T> featureType)
        Gets the feature of the given type, creating one if necessary. This method throws IllegalStateException if this node isn't configured to use the desired feature. Use hasFeature(Class) to check whether a node is configured to use a specific feature.
        Type Parameters:
        T - the desired feature type
        Parameters:
        featureType - the desired feature type, not null
        Returns:
        a feature instance, not null

      • getFeatureIfInitialized

        public <T extends NodeFeature> Optional<T> getFeatureIfInitialized​(Class<T> featureType)
        Gets the feature of the given type if it has been initialized. This method throws IllegalStateException if this node isn't configured to use the desired feature. Use hasFeature(Class) to check whether a node is configured to use a specific feature.
        Type Parameters:
        T - the desired feature type
        Parameters:
        featureType - the desired feature type, not null
        Returns:
        a feature instance, or an empty optional if the feature is not yet initialized for this node

      • hasFeature

        public boolean hasFeature​(Class<? extends NodeFeature> featureType)
        Checks whether this node contains a feature.
        Parameters:
        featureType - the feature type to check for
        Returns:
        true if this node contains the feature; otherwise false

      • getId

        public int getId()
        Gets the id of this node. The id is unique within the state tree that the node belongs to. The id is 0 if the node does not belong to any state tree.
        Returns:
        the node id
        See Also:
        StateTree.getNodeById(int)

      • isAttached

        public boolean isAttached()
        Checks whether this node is attached to a state tree.
        Returns:
        true if this node is attached; false if this node is not attached

      • collectChanges

        public void collectChanges​(Consumer<NodeChange> collector)
        Collects all changes made to this node since the last time collectChanges(Consumer) has been called. If the node is recently attached, then the reported changes will be relative to a newly created node.

        WARNING: this is in fact an internal (private method) which is expected to be called from StateTree.collectChanges(Consumer) method only (which is effectively private itself). Don't call this method from any other place because it will break the expected UI state.

        Parameters:
        collector - a consumer accepting node changes

      • clearChanges

        public void clearChanges()
        Clears all changes recorded for this node. This method is public only for testing purposes.

      • visitNodeTree

        public void visitNodeTree​(Consumer<StateNode> visitor)
        Applies the visitor to this node and all its descendants.

        The visitor is first applied to this node (root) and then to children.

        Parameters:
        visitor - visitor to apply

      • addAttachListener

        public Registration addAttachListener​(Command attachListener)
        Adds a command as an attach listener. It is executed whenever this state node is attached to the state tree.
        Parameters:
        attachListener - the attach listener to add
        Returns:
        an event registration handle for removing the listener

      • addDetachListener

        public Registration addDetachListener​(Command detachListener)
        Adds a command as a detach listener. It is executed whenever this state node is detached from the state tree.
        Parameters:
        detachListener - the detach listener to add
        Returns:
        an event registration handle for removing the listener

      • getChangeTracker

        public <T extends Serializable> T getChangeTracker​(NodeFeature feature,
                                                   Supplier<T> factory)
        Gets or creates a change tracker object for the provided feature.
        Type Parameters:
        T - the change tracker type
        Parameters:
        feature - the feature for which to get a change tracker
        factory - a factory method used to create a new tracker if there isn't already one
        Returns:
        the change tracker to use

      • runWhenAttached

        public void runWhenAttached​(SerializableConsumer<UI> command)
        Runs the command when the node is attached to a UI.

        If the node is already attached when this method is called, the method is run immediately.

        Parameters:
        command - the command to run immediately or when the node is attached

      • isReportedFeature

        public boolean isReportedFeature​(Class<? extends NodeFeature> featureType)
        Returns whether the featureType should be reported to the client even if it doesn't contain any data.
        Parameters:
        featureType - feature type which needs to be populated on the client
        Returns:
        whether the feature required by the client side

      • updateActiveState

        public void updateActiveState()
        Update "active"/"inactive" state of the node.

        The node is considered as inactive if there is at least one feature whose NodeFeature.allowsChanges() method returns false or it has inactive ascendant.

        Inactive nodes should restrict their RPC communication with client: only features that returns false via their method allowsChanges() and reported features send their changes while the node is inactive (the latter features are necessary on the client side to be able to find a strategy which has to be selected to handle the node).

        Implementation Note: this is done as a separate method instead of calculating the state on the fly (checking all features) because each node needs to check this status on its own AND on its parents (may be all parents up to the root).

        See Also:
        NodeFeature.allowsChanges()

      • isInactive

        public boolean isInactive()
        Checks whether the node is active.

        Inactive node should not participate in any RPC communication.

        Returns:
        true if the node is inactive

      • isInert

        public boolean isInert()
        Returns whether or not this state node is inert and it should not receive any updates from the client side. Inert state is inherited from parent, unless explicitly set to ignore parent inert state.

        The inert state is only updated when the changes are written to the client side, but the inert state is not sent to the client side - it is a server side feature only.

        Returns:
        true if the node is inert, false if not
        See Also:
        InertData

      • setEnabled

        public void setEnabled​(boolean enabled)
        Enables/disables the node.
        Parameters:
        enabled - a new enabled state

      • isEnabled

        public boolean isEnabled()
        Returns enabled state respecting ascendants state.

        The node may be explicitly disabled via its setEnabled(boolean) method (with false argument value). Also it may be implicitly disabled if its ascendant is explicitly disabled. The method returns the state which may be either explicit or implicit.

        The method isEnabledSelf() returns only explicit enabled state of the node.

        Returns:
        enabled state respecting ascendants state
        See Also:
        isEnabledSelf()

      • isEnabledSelf

        public boolean isEnabledSelf()
        Returns the enabled state only for this node.

        The node may be implicitly or explicitly disabled (see isEnabled() method). This method doesn't respect ascendants enabled state. It returns the own state for the node only.

        Returns:
        the node enabled own state
        See Also:
        isEnabled()