jakarta.faces.component.StateHolder Maven / Gradle / Ivy

/*
 * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package jakarta.faces.component;

import jakarta.faces.context.FacesContext;

/**
 *
 * 
 * This interface is implemented by classes that need to save their
 * state between requests.
 * 
 *
 * 
 * An implementor must implement both {@link #saveState} and {@link #restoreState} methods in this
 * class, since these two methods have a tightly coupled contract between themselves. In other words, if there is an
 * ineritance hierarchy, it is not permissable to have the {@link #saveState} and {@link #restoreState} methods reside
 * at different levels of the hierarchy.
 * 
 *
 * 
 * An implementor must have a public no-args constructor.
 * 
 *
 */

public interface StateHolder {

    /**
     * 
     * Gets the state of the instance as a Serializable Object.
     * 
     *
     * 
     * If the class that implements this interface has references to instances that implement StateHolder (such as a
     * UIComponent with event handlers, validators, etc.) this method must call the {@link #saveState} method
     * on all those instances as well. This method must not save the state of children and facets. That is
     * done via the {@link jakarta.faces.application.StateManager}
     * 
     *
     * 
     * This method must not alter the state of the implementing object. In other words, after executing this code:
     * 
     *
     *      * 
     * Object state = component.saveState(facesContext);
     * 
     * 
     *
     * 
     * component should be the same as before executing it.
     * 
     *
     * 
     * The return from this method must be Serializable
     * 
     *
     * @param context the Faces context.
     * @return the saved state.
     * @throws NullPointerException if context is null
     */

    Object saveState(FacesContext context);

    /**
     *
     * 
     * Perform any processing required to restore the state from the entries
     * in the state Object.
     * 
     *
     * 
     * If the class that implements this interface has references to instances that also implement StateHolder (such as a
     * UIComponent with event handlers, validators, etc.) this method must call the {@link #restoreState}
     * method on all those instances as well.
     * 
     *
     * 
     * If the state argument is null, take no action and return.
     * 
     *
     * @param context the Faces context.
     * @param state the state.
     * @throws NullPointerException if context is null.
     */

    void restoreState(FacesContext context, Object state);

    /**
     *
     * 
     * If true, the Object implementing this interface must not participate in state saving or restoring.
     * 
     *
     * @return true if transient, false otherwise.
     */

    boolean isTransient();

    /**
     * 
     * Denotes whether or not the Object implementing this interface must or
     * must not participate in state saving or restoring.
     * 
     *
     * @param newTransientValue boolean pass true if this Object will
     * not participate in state saving or restoring, otherwise pass false.
     */
    void setTransient(boolean newTransientValue);

}