| /* Encoder.java |
| Copyright (C) 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.beans; |
| |
| import gnu.java.beans.DefaultExceptionListener; |
| import gnu.java.beans.encoder.ArrayPersistenceDelegate; |
| import gnu.java.beans.encoder.ClassPersistenceDelegate; |
| import gnu.java.beans.encoder.CollectionPersistenceDelegate; |
| import gnu.java.beans.encoder.MapPersistenceDelegate; |
| import gnu.java.beans.encoder.PrimitivePersistenceDelegate; |
| |
| import java.util.AbstractCollection; |
| import java.util.HashMap; |
| import java.util.IdentityHashMap; |
| |
| /** |
| * @author Robert Schuster (robertschuster@fsfe.org) |
| * @since 1.4 |
| */ |
| public class Encoder |
| { |
| |
| /** |
| * An internal DefaultPersistenceDelegate instance that is used for every |
| * class that does not a have a special special PersistenceDelegate. |
| */ |
| private static PersistenceDelegate defaultPersistenceDelegate; |
| |
| private static PersistenceDelegate fakePersistenceDelegate; |
| |
| /** |
| * Stores the relation Class->PersistenceDelegate. |
| */ |
| private static HashMap delegates = new HashMap(); |
| |
| /** |
| * Stores the relation oldInstance->newInstance |
| */ |
| private IdentityHashMap candidates = new IdentityHashMap(); |
| |
| private ExceptionListener exceptionListener; |
| |
| /** |
| * A simple number that is used to restrict the access to writeExpression and |
| * writeStatement. The rule is that both methods should only be used when an |
| * object is written to the stream (= writeObject). Therefore accessCounter is |
| * incremented just before the call to writeObject and decremented afterwards. |
| * Then writeStatement and writeExpression allow execution only if |
| * accessCounter is bigger than zero. |
| */ |
| private int accessCounter = 0; |
| |
| public Encoder() |
| { |
| setupDefaultPersistenceDelegates(); |
| |
| setExceptionListener(null); |
| } |
| |
| /** |
| * Sets up a bunch of {@link PersistenceDelegate} instances which are needed |
| * for the basic working of a {@link Encoder}s. |
| */ |
| private static void setupDefaultPersistenceDelegates() |
| { |
| synchronized (delegates) |
| { |
| if (defaultPersistenceDelegate != null) |
| return; |
| |
| delegates.put(Class.class, new ClassPersistenceDelegate()); |
| |
| PersistenceDelegate pd = new PrimitivePersistenceDelegate(); |
| delegates.put(Boolean.class, pd); |
| delegates.put(Byte.class, pd); |
| delegates.put(Short.class, pd); |
| delegates.put(Integer.class, pd); |
| delegates.put(Long.class, pd); |
| delegates.put(Float.class, pd); |
| delegates.put(Double.class, pd); |
| |
| delegates.put(Object[].class, new ArrayPersistenceDelegate()); |
| |
| pd = new CollectionPersistenceDelegate(); |
| delegates.put(AbstractCollection.class, pd); |
| |
| pd = new MapPersistenceDelegate(); |
| delegates.put(java.util.AbstractMap.class, pd); |
| delegates.put(java.util.Hashtable.class, pd); |
| |
| defaultPersistenceDelegate = new DefaultPersistenceDelegate(); |
| delegates.put(Object.class, defaultPersistenceDelegate); |
| |
| // Creates a PersistenceDelegate implementation which is |
| // returned for 'null'. In practice this instance is |
| // not used in any way and is just here to be compatible |
| // with the reference implementation which returns a |
| // similar instance when calling getPersistenceDelegate(null) . |
| fakePersistenceDelegate = new PersistenceDelegate() |
| { |
| protected Expression instantiate(Object o, Encoder e) |
| { |
| return null; |
| } |
| }; |
| |
| } |
| } |
| |
| protected void writeObject(Object o) |
| { |
| // 'null' has no PersistenceDelegate and will not |
| // create an Expression which has to be cloned. |
| // However subclasses should be aware that writeObject |
| // may be called with a 'null' argument and should |
| // write the proper representation of it. |
| if (o == null) |
| return; |
| |
| PersistenceDelegate pd = getPersistenceDelegate(o.getClass()); |
| |
| accessCounter++; |
| pd.writeObject(o, this); |
| accessCounter--; |
| |
| } |
| |
| /** |
| * Sets the {@link ExceptionListener} instance to be used for reporting |
| * recorable exceptions in the instantiation and initialization sequence. If |
| * the argument is <code>null</code> a default instance will be used that |
| * prints the thrown exception to <code>System.err</code>. |
| */ |
| public void setExceptionListener(ExceptionListener listener) |
| { |
| exceptionListener = (listener != null) |
| ? listener : DefaultExceptionListener.INSTANCE; |
| } |
| |
| /** |
| * Returns the currently active {@link ExceptionListener} instance. |
| */ |
| public ExceptionListener getExceptionListener() |
| { |
| return exceptionListener; |
| } |
| |
| public PersistenceDelegate getPersistenceDelegate(Class type) |
| { |
| // This is not specified but the JDK behaves like this. |
| if (type == null) |
| return fakePersistenceDelegate; |
| |
| // Treats all array classes in the same way and assigns |
| // them a shared PersistenceDelegate implementation tailored |
| // for array instantation and initialization. |
| if (type.isArray()) |
| return (PersistenceDelegate) delegates.get(Object[].class); |
| |
| PersistenceDelegate pd = (PersistenceDelegate) delegates.get(type); |
| |
| return (pd != null) ? pd : (PersistenceDelegate) defaultPersistenceDelegate; |
| } |
| |
| /** |
| * Sets the {@link PersistenceDelegate} instance for the given class. |
| * <p> |
| * Note: Throws a <code>NullPointerException</code> if the argument is |
| * <code>null</code>. |
| * </p> |
| * <p> |
| * Note: Silently ignores PersistenceDelegates for Array types and primitive |
| * wrapper classes. |
| * </p> |
| * <p> |
| * Note: Although this method is not declared <code>static</code> changes to |
| * the {@link PersistenceDelegate}s affect <strong>all</strong> |
| * {@link Encoder} instances. <strong>In this implementation</strong> the |
| * access is thread safe. |
| * </p> |
| */ |
| public void setPersistenceDelegate(Class type, PersistenceDelegate delegate) |
| { |
| // If the argument is null this will cause a NullPointerException |
| // which is expected behavior. |
| |
| // This makes custom PDs for array, primitive types and their wrappers |
| // impossible but this is how the JDK behaves. |
| if (type.isArray() || type.isPrimitive() || type == Boolean.class |
| || type == Byte.class || type == Short.class || type == Integer.class |
| || type == Long.class || type == Float.class || type == Double.class) |
| return; |
| |
| synchronized (delegates) |
| { |
| delegates.put(type, delegate); |
| } |
| |
| } |
| |
| public Object remove(Object oldInstance) |
| { |
| return candidates.remove(oldInstance); |
| } |
| |
| /** |
| * Returns the replacement object which has been created by the encoder during |
| * the instantiation sequence or <code>null</code> if the object has not |
| * been processed yet. |
| * <p> |
| * Note: The <code>String</code> class acts as an endpoint for the |
| * inherently recursive algorithm of the {@link Encoder}. Therefore instances |
| * of <code>String</code> will always be returned by this method. In other |
| * words the assertion: <code> |
| * assert (anyEncoder.get(anyString) == anyString) |
| * </code< |
| * will always hold.</p> |
| * |
| * <p>Note: If <code>null</code> is requested, the result will |
| * always be <code>null</code>.</p> |
| */ |
| public Object get(Object oldInstance) |
| { |
| // String instances are handled in a special way. |
| // No one knows why this is not officially specified |
| // because this is a rather important design decision. |
| return (oldInstance == null) ? null : |
| (oldInstance.getClass() == String.class) ? |
| oldInstance : candidates.get(oldInstance); |
| } |
| |
| /** |
| * <p> |
| * Note: If you call this method not from within an object instantiation and |
| * initialization sequence it will be silently ignored. |
| * </p> |
| */ |
| public void writeStatement(Statement stmt) |
| { |
| // Silently ignore out of bounds calls. |
| if (accessCounter <= 0) |
| return; |
| |
| Object target = stmt.getTarget(); |
| |
| Object newTarget = get(target); |
| if (newTarget == null) |
| { |
| writeObject(target); |
| newTarget = get(target); |
| } |
| |
| Object[] args = stmt.getArguments(); |
| Object[] newArgs = new Object[args.length]; |
| |
| for (int i = 0; i < args.length; i++) |
| { |
| newArgs[i] = get(args[i]); |
| if (newArgs[i] == null || isImmutableType(args[i].getClass())) |
| { |
| writeObject(args[i]); |
| newArgs[i] = get(args[i]); |
| } |
| } |
| |
| Statement newStmt = new Statement(newTarget, stmt.getMethodName(), newArgs); |
| |
| try |
| { |
| newStmt.execute(); |
| } |
| catch (Exception e) |
| { |
| exceptionListener.exceptionThrown(e); |
| } |
| |
| } |
| |
| /** |
| * <p> |
| * Note: If you call this method not from within an object instantiation and |
| * initialization sequence it will be silently ignored. |
| * </p> |
| */ |
| public void writeExpression(Expression expr) |
| { |
| // Silently ignore out of bounds calls. |
| if (accessCounter <= 0) |
| return; |
| |
| Object target = expr.getTarget(); |
| Object value = null; |
| Object newValue = null; |
| |
| try |
| { |
| value = expr.getValue(); |
| } |
| catch (Exception e) |
| { |
| exceptionListener.exceptionThrown(e); |
| return; |
| } |
| |
| |
| newValue = get(value); |
| |
| if (newValue == null) |
| { |
| Object newTarget = get(target); |
| if (newTarget == null) |
| { |
| writeObject(target); |
| newTarget = get(target); |
| |
| // May happen if exception was thrown. |
| if (newTarget == null) |
| { |
| return; |
| } |
| } |
| |
| Object[] args = expr.getArguments(); |
| Object[] newArgs = new Object[args.length]; |
| |
| for (int i = 0; i < args.length; i++) |
| { |
| newArgs[i] = get(args[i]); |
| if (newArgs[i] == null || isImmutableType(args[i].getClass())) |
| { |
| writeObject(args[i]); |
| newArgs[i] = get(args[i]); |
| } |
| } |
| |
| Expression newExpr = new Expression(newTarget, expr.getMethodName(), |
| newArgs); |
| |
| // Fakes the result of Class.forName(<primitiveType>) to make it possible |
| // to hand such a type to the encoding process. |
| if (value instanceof Class && ((Class) value).isPrimitive()) |
| newExpr.setValue(value); |
| |
| // Instantiates the new object. |
| try |
| { |
| newValue = newExpr.getValue(); |
| |
| candidates.put(value, newValue); |
| } |
| catch (Exception e) |
| { |
| exceptionListener.exceptionThrown(e); |
| |
| return; |
| } |
| |
| writeObject(value); |
| |
| } |
| else if(value.getClass() == String.class || value.getClass() == Class.class) |
| { |
| writeObject(value); |
| } |
| |
| } |
| |
| /** Returns whether the given class is an immutable |
| * type which has to be handled differently when serializing it. |
| * |
| * <p>Immutable objects always have to be instantiated instead of |
| * modifying an existing instance.</p> |
| * |
| * @param type The class to test. |
| * @return Whether the first argument is an immutable type. |
| */ |
| boolean isImmutableType(Class type) |
| { |
| return type == String.class || type == Class.class |
| || type == Integer.class || type == Boolean.class |
| || type == Byte.class || type == Short.class |
| || type == Long.class || type == Float.class |
| || type == Double.class; |
| } |
| |
| /** Sets the stream candidate for a given object. |
| * |
| * @param oldObject The object given to the encoder. |
| * @param newObject The object the encoder generated. |
| */ |
| void putCandidate(Object oldObject, Object newObject) |
| { |
| candidates.put(oldObject, newObject); |
| } |
| |
| } |