javax.faces.event.ExceptionQueuedEventContext Maven / Gradle / Ivy
Show all versions of javax.faces Show documentation
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package javax.faces.event;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Collections;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
/**
* This helper class provides context to
* the {@link ExceptionQueuedEvent} regarding the state of the system at the
* point in time when the ExceptionQueuedEvent occurs and links
* the ExceptionQueuedEvent to the {@link
* javax.faces.context.ExceptionHandler} by virtue of implementing
* {@link SystemEventListener}.
*
* @since 2.0
*/
public class ExceptionQueuedEventContext implements SystemEventListenerHolder {
/**
* The presence of an entry under this
* key in the Map returned from {@link #getAttributes}
* indicates the event occurred during the “before
* phase” part of the current lifecycle phase.
*/
public static final String IN_BEFORE_PHASE_KEY =
ExceptionQueuedEventContext.class.getName() + ".IN_BEFORE_PHASE";
/**
* The presence of an entry under this
* key in the Map returned from {@link #getAttributes}
* indicates the event occurred during the “after
* phase” part of the current lifecycle phase.
*/
public static final String IN_AFTER_PHASE_KEY =
ExceptionQueuedEventContext.class.getName() + ".IN_AFTER_PHASE";
private FacesContext context;
private Throwable thrown;
private UIComponent component;
private PhaseId phaseId;
private Map attributes;
private List listener;
// ------------------------------------------------------------ Constructors
/**
* Instantiate a new
* ExceptionQueuedEventContext that indicates the argument
* Throwable just occurred.
*
* @param context {@link FacesContext} for the current request
* @param thrown the Throwable that is the context for
* this ExceptionQueuedEventContext instance.
*/
public ExceptionQueuedEventContext(FacesContext context, Throwable thrown) {
this(context, thrown, null, null);
}
/**
* Instantiate a new
* ExceptionQueuedEventContext that indicates the argument
* Throwable just occurred, relevant to the argument
* component.
*
* @param context {@link FacesContext} for the current request
* @param thrown the Throwable that is the context for
* this ExceptionQueuedEventContext instance.
* @param component the {@link UIComponent} instance to which this
* ExceptionQueuedEventContext pertains
*/
public ExceptionQueuedEventContext(FacesContext context,
Throwable thrown,
UIComponent component) {
this (context, thrown, component, null);
}
/**
*
Instantiate a new
* ExceptionQueuedEventContext that indicates the argument
* Throwable just occurred, relevant to the argument
* component, during the lifecycle phase
* phaseId.
*
* @param context {@link FacesContext} for the current request
* @param thrown the Throwable that is the context for
* this ExceptionQueuedEventContext instance.
*
* @param component the UIComponent that is relevant to
* the context.
*
* @param phaseId the PhaseId at the time this
* ExeceptionEventContext is created.
*/
public ExceptionQueuedEventContext(FacesContext context,
Throwable thrown,
UIComponent component,
PhaseId phaseId) {
this.context = context;
this.thrown = thrown;
this.component = component;
this.phaseId = ((phaseId == null)
? context.getCurrentPhaseId()
: phaseId);
}
// ---------------------------------------------------------- Public Methods
/**
*
* @return the {@link FacesContext} used to create this
* ExceptionQueuedEventContext instance.
*/
public FacesContext getContext() {
return context;
}
/**
* Return the exception
* property.
*/
public Throwable getException() {
return thrown;
}
/**
* Return the UIComponent
* which was being processed when the exception was thrown. If none
* or not available, this will be null.
*/
public UIComponent getComponent() {
return this.component;
}
/**
* Return the PhaseId
* which was being processed when the exception was thrown. If none
* or not available, this will be null.
*/
public PhaseId getPhaseId() {
return this.phaseId;
}
/**
* @return true if the exception occurred during the
* before phase processing for a particular lifecycle
* phase
*/
public boolean inBeforePhase() {
return isAttributeDefined(IN_BEFORE_PHASE_KEY);
}
/**
* @return true if the exception occurred during the
* after phase processing for a particular lifecycle
* phase
*/
public boolean inAfterPhase() {
return isAttributeDefined(IN_AFTER_PHASE_KEY);
}
/**
* A Map of attributes
* relevant to the context of this ExceptionQueuedEvent.
*/
public Map getAttributes() {
if (null == attributes) {
attributes = new HashMap();
}
return attributes;
}
/**
* Return a List that
* contains a single entry, the {@link
* javax.faces.context.ExceptionHandler} for the current
* request.
*/
public List getListenersForEventClass(Class facesEventClass) {
if (null == listener) {
List list = new ArrayList(1);
list.add(context.getExceptionHandler());
listener = Collections.unmodifiableList(list);
}
return listener;
}
// --------------------------------------------------------- Private Methods
private boolean isAttributeDefined(String key) {
return ((attributes != null) && attributes.containsKey(key));
}
}