/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.core.server;
import com.google.gwt.core.shared.GWT;
import com.google.gwt.core.shared.GWTBridge;
import com.google.gwt.i18n.server.GwtLocaleFactoryImpl;
import com.google.gwt.i18n.shared.GwtLocale;
import com.google.gwt.i18n.shared.GwtLocaleFactory;
import com.google.gwt.i18n.shared.Localizable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Implements GWT.* methods for the server.
*/
public class ServerGwtBridge extends GWTBridge {
/**
* Something that knows how to provide an instance of a requested class.
*/
public interface ClassInstantiator {
/**
* Create an instance given a base class. The created class may be a
* subtype of the requested class.
*
* @param <T>
* @param baseClass
* @param properties
* @return instance or null if unable to create
*/
<T> T create(Class<?> baseClass, Properties properties);
}
/**
* Helper class that provides some wrappers for looking up and instantiating
* a class.
*/
public abstract static class ClassInstantiatorBase implements ClassInstantiator {
/**
* @param <T>
* @param clazz
* @return class instance or null
*/
protected <T> T tryCreate(Class<T> clazz) {
try {
T obj = clazz.newInstance();
return obj;
} catch (InstantiationException e) {
} catch (IllegalAccessException e) {
}
return null;
}
/**
* @param <T>
* @param className
* @return class instance or null
*/
protected <T> T tryCreate(String className) {
try {
Class<?> clazz = Class.forName(className);
@SuppressWarnings("unchecked")
T obj = (T) tryCreate(clazz);
return obj;
} catch (ClassNotFoundException e) {
}
return null;
}
}
/**
* An interface for accessing property values.
*/
public interface Properties {
/**
* Get the value of a property.
*
* @param name
* @return property value, or null
*/
String getProperty(String name);
}
/**
* A node in the tree of registered classes, keeping track of class
* instantiators for each type. {@link Object} is at the root of the
* tree, and children are not related to each other but inherit from
* their parent.
*/
private static class Node {
public final Class<?> type;
public final ArrayList<Node> children;
public final ArrayList<ClassInstantiator> instantiators;
public Node(Class<?> type) {
this.type = type;
children = new ArrayList<Node>();
instantiators = new ArrayList<ClassInstantiator>();
}
}
private static class PropertiesImpl implements Properties {
private final Object lock = new Object[0];
private final Map<String, String> map = new HashMap<String, String>();
@Override
public String getProperty(String name) {
synchronized (lock) {
return map.get(name);
}
}
public void setProperty(String name, String value) {
synchronized (lock) {
map.put(name, value);
}
}
}
/**
* Lookup a property first in thread-local properties, then in global
* properties.
*/
private class PropertyLookup implements Properties {
@Override
public String getProperty(String name) {
String val = threadProperties.get().getProperty(name);
if (val == null) {
val = globalProperties.getProperty(name);
}
return val;
}
}
private static Object instanceLock = new Object[0];
private static ServerGwtBridge instance = null;
private static final GwtLocaleFactory factory = new GwtLocaleFactoryImpl();
private static final Logger LOGGER = Logger.getLogger(ServerGwtBridge.class.getName());
/**
* Get the singleton {@link ServerGwtBridge} instance, creating it if
* necessary. The instance will be registered via
* {@link GWT#setBridge(GWTBridge)} and will have the default instantiators
* registered on it.
*
* @return the singleton {@link ServerGwtBridge} instance
*/
public static ServerGwtBridge getInstance() {
synchronized (instanceLock) {
if (instance == null) {
instance = new ServerGwtBridge();
GWT.setBridge(instance);
}
return instance;
}
}
public static GwtLocale getLocale(Properties properties) {
String propVal = properties.getProperty("locale");
if (propVal == null) {
propVal = "default";
}
return factory.fromString(propVal);
}
/**
* Root of the tree of registered classes and their instantiators.
*/
private final Node root = new Node(Object.class);
// lock for instantiators
private final Object instantiatorsLock = new Object[0];
private final ThreadLocal<PropertiesImpl> threadProperties;
private final PropertiesImpl globalProperties = new PropertiesImpl();
private Properties properties = new PropertyLookup();
// @VisibleForTesting
ServerGwtBridge() {
threadProperties = new ThreadLocal<PropertiesImpl>() {
@Override
protected PropertiesImpl initialValue() {
return new PropertiesImpl();
}
};
// register built-in instantiators
register(Object.class, new ObjectNew());
register(Localizable.class, new LocalizableInstantiator());
}
@Override
public <T> T create(Class<?> classLiteral) {
synchronized (instantiatorsLock) {
// Start at the root, and find the bottom-most node that our type
// is assignable to.
Stack<Node> stack = new Stack<Node>();
stack.push(root);
boolean found;
do {
found = false;
Node node = stack.peek();
for (Node child : node.children) {
if (child.type.isAssignableFrom(classLiteral)) {
found = true;
stack.push(child);
break;
}
}
} while (found);
// Try each instantiator until we find one that can create the
// type, walking up the tree.
while (!stack.isEmpty()) {
Node node = stack.pop();
for (ClassInstantiator inst : node.instantiators) {
T obj = inst.<T>create(classLiteral, properties);
if (obj != null) {
return obj;
}
}
}
throw new RuntimeException("No instantiator created " + classLiteral.getCanonicalName());
}
}
/**
* Get the value of the named property, preferring a value specific to this
* thread (see {@link #setThreadProperty(String, String)}) over one that is
* set globally (see {@link #setGlobalProperty(String, String)}).
*
* @param property
* @return the property's value or null if none
*/
public String getProperty(String property) {
return properties.getProperty(property);
}
@Override
public String getVersion() {
return "unknown";
}
@Override
public boolean isClient() {
return false;
}
@Override
public void log(String message, Throwable e) {
LOGGER.log(Level.INFO, message, e);
}
/**
* Register an instantiator to be used for any subtypes of a given base class.
*
* @param baseClass
* @param instantiator
*/
public void register(Class<?> baseClass, ClassInstantiator instantiator) {
synchronized (instantiatorsLock) {
// find the deepest node which is baseClass or a supertype
Node node = root;
boolean found;
do {
found = false;
for (Node child : node.children) {
if (child.type.isAssignableFrom(baseClass)) {
found = true;
node = child;
}
}
} while (found);
// add the instantiator to the found node if it is an exact match, or
// create a new one if not and insert it in the proper place
Node nodeToAdd = node;
if (node.type != baseClass) {
nodeToAdd = new Node(baseClass);
// check if this node's children extend baseClass, if so we need
// to insert a new node between them
boolean needsAdd = true;
for (Node child : node.children) {
if (baseClass.isAssignableFrom(child.type)) {
nodeToAdd.children.add(child);
int childPosition = node.children.indexOf(child);
node.children.set(childPosition, nodeToAdd);
needsAdd = false;
break;
}
}
if (needsAdd) {
node.children.add(nodeToAdd);
}
}
nodeToAdd.instantiators.add(0, instantiator);
}
}
/**
* Set a property value globally. This value will be overridden by any
* thread-specific property value of the same name.
*
* @param property
* @param value
*/
public void setGlobalProperty(String property, String value) {
globalProperties.setProperty(property, value);
}
/**
* Set a property value for only the current thread. This value will override
* any global property value of the same name.
*
* @param property
* @param value
*/
public void setThreadProperty(String property, String value) {
threadProperties.get().setProperty(property, value);
}
}