com.sun.faces.taglib.jsf_core.LoadBundleTag Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javax.faces Show documentation
Show all versions of javax.faces Show documentation
This is the master POM file for Oracle's Implementation of the JSF 2.0 Specification.
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2011 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 com.sun.faces.taglib.jsf_core;
import static com.sun.faces.config.WebConfiguration.BooleanWebContextInitParameter;
import com.sun.faces.config.WebConfiguration;
import com.sun.faces.el.ELUtils;
import com.sun.faces.util.FacesLogger;
import com.sun.faces.util.MessageUtils;
import com.sun.faces.util.ReflectionUtils;
import com.sun.faces.util.Util;
import com.sun.faces.util.RequestStateManager;
import javax.el.ValueExpression;
import javax.faces.component.UIComponent;
import javax.faces.component.UIComponentBase;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.webapp.UIComponentClassicTagBase;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.Stack;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Tag action that loads the specified ResourceBundle as a Map into
* the request scope of the current {@link
* javax.faces.context.FacesContext}.
*
* The user is discouraged from using multiple dot syntax in their
* resource bundle keys. For example, for the bundle loaded under the
* var msgs
, this key: index.page.title
is
* discouraged. If your application requires this syntax for resource
* bundle keys, they may be referred to in the page with a syntax like
* this: #{msgs["index.page.title"]}.
*/
public class LoadBundleTag extends TagSupport {
static final String
PRE_VIEW_LOADBUNDLES_LIST_ATTR_NAME =
"com.sun.faces.taglib.jsf_core.PRE_VIEW_LOADBUNDLES_LIST";
private static final Logger LOGGER = FacesLogger.TAGLIB.getLogger();
// ------------------------------------------------------------- Attributes
private ValueExpression basenameExpression;
/**
* Set the base name of the ResourceBundle
to be
* loaded.
* @param basename the ValueExpression which will resolve the basename
*/
public void setBasename(ValueExpression basename) {
this.basenameExpression = basename;
}
private String var;
/**
* Set the name of the attribute in the request scope under which
* to store the ResourceBundle
Map
.
* @param var the variable name to export the loaded ResourceBundle to
*/
public void setVar(String var) {
this.var = var;
}
// --------------------------------------------------------- Public Methods
/**
* Load the ResourceBundle
named by our
* basename
property.
Wrap it in an immutable
* Map
implementation and store the Map
in
* the request attr set of under the key given by our
* var
property.
*
* @throws JspException if a JSP error occurs
*/
public int doStartTag() throws JspException {
FacesContext context = FacesContext.getCurrentInstance();
// evaluate any VB expression that we were passed
String basename;
basename = (String)
ELUtils.evaluateValueExpression(basenameExpression,
context.getELContext());
if (null == basename) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "baseName");
throw new NullPointerException(message);
}
if (null == var) {
String message = MessageUtils.getExceptionMessageString
(MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "baseName");
throw new NullPointerException(message);
}
final ResourceBundle bundle =
ResourceBundle.getBundle(basename,
context.getViewRoot().getLocale(),
Util.getCurrentLoader(this));
if (null == bundle) {
throw new JspException("null ResourceBundle for " + basename);
}
Map toStore =
new Map() {
// this is an immutable Map
public String toString() {
StringBuffer sb = new StringBuffer();
Iterator> entries =
this.entrySet().iterator();
Map.Entry cur;
while (entries.hasNext()) {
cur = entries.next();
sb.append(cur.getKey()).append(": ").append(cur.getValue()).append('\n');
}
return sb.toString();
}
// Do not need to implement for immutable Map
public void clear() {
throw new UnsupportedOperationException();
}
public boolean containsKey(Object key) {
boolean result = false;
if (null != key) {
result = (null != bundle.getObject(key.toString()));
}
return result;
}
public boolean containsValue(Object value) {
Enumeration keys = bundle.getKeys();
boolean result = false;
while (keys.hasMoreElements()) {
Object curObj = bundle.getObject(keys.nextElement());
if ((curObj == value) ||
((null != curObj) && curObj.equals(value))) {
result = true;
break;
}
}
return result;
}
public Set> entrySet() {
HashMap mappings = new HashMap();
Enumeration keys = bundle.getKeys();
while (keys.hasMoreElements()) {
String key = keys.nextElement();
Object value = bundle.getObject(key);
mappings.put(key, value);
}
return mappings.entrySet();
}
public boolean equals(Object obj) {
return !((obj == null) || !(obj instanceof Map))
&& entrySet().equals(((Map) obj).entrySet());
}
public Object get(Object key) {
if (null == key) {
return null;
}
try {
return bundle.getObject(key.toString());
} catch (MissingResourceException e) {
return "???" + key + "???";
}
}
public int hashCode() {
return bundle.hashCode();
}
public boolean isEmpty() {
Enumeration keys = bundle.getKeys();
return !keys.hasMoreElements();
}
public Set keySet() {
Set keySet = new HashSet();
Enumeration keys = bundle.getKeys();
while (keys.hasMoreElements()) {
keySet.add(keys.nextElement());
}
return keySet;
}
// Do not need to implement for immutable Map
public Object put(Object k, Object v) {
throw new UnsupportedOperationException();
}
// Do not need to implement for immutable Map
public void putAll(Map t) {
throw new UnsupportedOperationException();
}
// Do not need to implement for immutable Map
public Object remove(Object k) {
throw new UnsupportedOperationException();
}
public int size() {
int result = 0;
Enumeration keys = bundle.getKeys();
while (keys.hasMoreElements()) {
keys.nextElement();
result++;
}
return result;
}
public java.util.Collection values() {
ArrayList