From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../java/beans/DefaultPersistenceDelegate.java | 211 +++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 libjava/classpath/java/beans/DefaultPersistenceDelegate.java (limited to 'libjava/classpath/java/beans/DefaultPersistenceDelegate.java') diff --git a/libjava/classpath/java/beans/DefaultPersistenceDelegate.java b/libjava/classpath/java/beans/DefaultPersistenceDelegate.java new file mode 100644 index 000000000..3a4d86cca --- /dev/null +++ b/libjava/classpath/java/beans/DefaultPersistenceDelegate.java @@ -0,0 +1,211 @@ +/* DefaultPersistenceDelegate.java + Copyright (C) 2005 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 java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/**

DefaultPersistenceDelegate is a {@link PersistenceDelegate} + * implementation that can be used to serialize objects which adhere to the + * Java Beans naming convention.

+ * + * @author Robert Schuster (robertschuster@fsfe.org) + * @since 1.4 + */ +public class DefaultPersistenceDelegate extends PersistenceDelegate +{ + + private String[] constructorPropertyNames; + + /** Using this constructor the object to be serialized will be instantiated + * with the default non-argument constructor. + */ + public DefaultPersistenceDelegate() + { + } + + /** This constructor allows to specify which Bean properties appear + * in the constructor. + * + *

The implementation reads the mentioned properties from the Bean + * instance and applies it in the given order to a corresponding + * constructor.

+ * + * @param constructorPropertyNames The properties the Bean's constructor + * should be given to. + */ + public DefaultPersistenceDelegate(String[] constructorPropertyNames) + { + this.constructorPropertyNames = constructorPropertyNames; + } + + protected boolean mutatesTo(Object oldInstance, Object newInstance) + { + try + { + + return (constructorPropertyNames != null + && constructorPropertyNames.length > 0 + && oldInstance.getClass() + .getDeclaredMethod("equals", + new Class[] { Object.class }) != null) + ? oldInstance.equals(newInstance) + : super.mutatesTo(oldInstance, newInstance); + } + catch (NoSuchMethodException nsme) + { + return super.mutatesTo(oldInstance, newInstance); + } + } + + protected Expression instantiate(Object oldInstance, Encoder out) + { + Object[] args = null; + + try + { + // If there are property names in the array, then we create + // a corresponding argument array and store every + // argument in it. To retrieve an argument object we have + // dig up the right property in the bean class' BeanInfo + // object. + // This is so costly in terms of execution time I better + // not think twice about it ... + if (constructorPropertyNames != null) + { + args = new Object[constructorPropertyNames.length]; + + // Look up the properties of oldInstance's class to find matches for + // the + // names given in the constructor. + PropertyDescriptor[] propertyDescs = Introspector.getBeanInfo( + oldInstance.getClass()).getPropertyDescriptors(); + + for (int i = 0; i < constructorPropertyNames.length; i++) + { + // Scan the property descriptions for a matching name. + for (int j = 0; j < propertyDescs.length; j++) + { + if (propertyDescs[i].getName().equals( + constructorPropertyNames[i])) + { + Method readMethod = propertyDescs[i].getReadMethod(); + + args[i] = readMethod.invoke(oldInstance); + } + } + } + } + + } + catch (IllegalAccessException iae) + { + out.getExceptionListener().exceptionThrown(iae); + } + catch (IllegalArgumentException iarge) + { + out.getExceptionListener().exceptionThrown(iarge); + } + catch (InvocationTargetException ite) + { + out.getExceptionListener().exceptionThrown(ite); + } + catch (IntrospectionException ie) + { + out.getExceptionListener().exceptionThrown(ie); + } + + return new Expression(oldInstance, oldInstance.getClass(), "new", args); + } + + protected void initialize(Class type, Object oldInstance, + Object newInstance, Encoder out) + { + // Calling the supertype's implementation of initialize makes it + // possible that descendants of classes like AbstractHashMap + // or Hashtable are serialized correctly. This mechanism grounds on + // two other facts: + // * Each class which has not registered a special purpose + // PersistenceDelegate is handled by a DefaultPersistenceDelegate + // instance. + // * PersistenceDelegate.initialize() is implemented in a way that it + // calls the initialize method of the superclass' persistence delegate. + super.initialize(type, oldInstance, newInstance, out); + + // Suppresses the writing of property setting statements when this delegate + // is not used for the exact instance type. By doing so the following code + // is called only once per object. + if (type != oldInstance.getClass()) + return; + + try + { + PropertyDescriptor[] propertyDescs = Introspector.getBeanInfo( + oldInstance.getClass()).getPropertyDescriptors(); + + for (int i = 0; i < propertyDescs.length; i++) + { + Method readMethod = propertyDescs[i].getReadMethod(); + Method writeMethod = propertyDescs[i].getWriteMethod(); + + if (readMethod != null && writeMethod != null) + { + Object oldValue = readMethod.invoke(oldInstance); + + if (oldValue != null) + out.writeStatement(new Statement(oldInstance, + writeMethod.getName(), + new Object[] { oldValue })); + } + } + } + catch (IntrospectionException ie) + { + out.getExceptionListener().exceptionThrown(ie); + } + catch (IllegalAccessException iae) + { + out.getExceptionListener().exceptionThrown(iae); + } + catch (InvocationTargetException ite) + { + out.getExceptionListener().exceptionThrown(ite); + } + } +} -- cgit v1.2.3