Source for java.beans.Encoder

 1:  /* Encoder.java
 2:  Copyright (C) 2005, 2006 Free Software Foundation, Inc.
 3: 
 4:  This file is part of GNU Classpath.
 5: 
 6:  GNU Classpath is free software; you can redistribute it and/or modify
 7:  it under the terms of the GNU General Public License as published by
 8:  the Free Software Foundation; either version 2, or (at your option)
 9:  any later version.
 10: 
 11:  GNU Classpath is distributed in the hope that it will be useful, but
 12:  WITHOUT ANY WARRANTY; without even the implied warranty of
 13:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 14:  General Public License for more details.
 15: 
 16:  You should have received a copy of the GNU General Public License
 17:  along with GNU Classpath; see the file COPYING. If not, write to the
 18:  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 19:  02110-1301 USA.
 20: 
 21:  Linking this library statically or dynamically with other modules is
 22:  making a combined work based on this library. Thus, the terms and
 23:  conditions of the GNU General Public License cover the whole
 24:  combination.
 25: 
 26:  As a special exception, the copyright holders of this library give you
 27:  permission to link this library with independent modules to produce an
 28:  executable, regardless of the license terms of these independent
 29:  modules, and to copy and distribute the resulting executable under
 30:  terms of your choice, provided that you also meet, for each linked
 31:  independent module, the terms and conditions of the license of that
 32:  module. An independent module is a module which is not derived from
 33:  or based on this library. If you modify this library, you may extend
 34:  this exception to your version of the library, but you are not
 35:  obligated to do so. If you do not wish to do so, delete this
 36:  exception statement from your version. */
 37: 
 38: 
 39:  package java.beans;
 40: 
 41:  import gnu.java.beans.DefaultExceptionListener;
 42:  import gnu.java.beans.encoder.ArrayPersistenceDelegate;
 43:  import gnu.java.beans.encoder.ClassPersistenceDelegate;
 44:  import gnu.java.beans.encoder.CollectionPersistenceDelegate;
 45:  import gnu.java.beans.encoder.MapPersistenceDelegate;
 46:  import gnu.java.beans.encoder.PrimitivePersistenceDelegate;
 47: 
 48:  import java.util.AbstractCollection;
 49:  import java.util.HashMap;
 50:  import java.util.IdentityHashMap;
 51: 
 52:  /**
 53:  * @author Robert Schuster (robertschuster@fsfe.org)
 54:  * @since 1.4
 55:  */
 56:  public class Encoder
 57: {
 58: 
 59:  /**
 60:  * An internal DefaultPersistenceDelegate instance that is used for every
 61:  * class that does not a have a special special PersistenceDelegate.
 62:  */
 63:  private static PersistenceDelegate defaultPersistenceDelegate;
 64: 
 65:  private static PersistenceDelegate fakePersistenceDelegate;
 66: 
 67:  /**
 68:  * Stores the relation Class->PersistenceDelegate.
 69:  */
 70:  private static HashMap delegates = new HashMap();
 71: 
 72:  /**
 73:  * Stores the relation oldInstance->newInstance
 74:  */
 75:  private IdentityHashMap candidates = new IdentityHashMap();
 76: 
 77:  private ExceptionListener exceptionListener;
 78: 
 79:  /**
 80:  * A simple number that is used to restrict the access to writeExpression and
 81:  * writeStatement. The rule is that both methods should only be used when an
 82:  * object is written to the stream (= writeObject). Therefore accessCounter is
 83:  * incremented just before the call to writeObject and decremented afterwards.
 84:  * Then writeStatement and writeExpression allow execution only if
 85:  * accessCounter is bigger than zero.
 86:  */
 87:  private int accessCounter = 0;
 88: 
 89:  public Encoder()
 90:  {
 91:  setupDefaultPersistenceDelegates();
 92: 
 93:  setExceptionListener(null);
 94:  }
 95: 
 96:  /**
 97:  * Sets up a bunch of {@link PersistenceDelegate} instances which are needed
 98:  * for the basic working of a {@link Encoder}s.
 99:  */
 100:  private static void setupDefaultPersistenceDelegates()
 101:  {
 102:  synchronized (delegates)
 103:  {
 104:  if (defaultPersistenceDelegate != null)
 105:  return;
 106: 
 107:  delegates.put(Class.class, new ClassPersistenceDelegate());
 108: 
 109:  PersistenceDelegate pd = new PrimitivePersistenceDelegate();
 110:  delegates.put(Boolean.class, pd);
 111:  delegates.put(Byte.class, pd);
 112:  delegates.put(Short.class, pd);
 113:  delegates.put(Integer.class, pd);
 114:  delegates.put(Long.class, pd);
 115:  delegates.put(Float.class, pd);
 116:  delegates.put(Double.class, pd);
 117: 
 118:  delegates.put(Object[].class, new ArrayPersistenceDelegate());
 119: 
 120:  pd = new CollectionPersistenceDelegate();
 121:  delegates.put(AbstractCollection.class, pd);
 122:  
 123:  pd = new MapPersistenceDelegate();
 124:  delegates.put(java.util.AbstractMap.class, pd);
 125:  delegates.put(java.util.Hashtable.class, pd);
 126:  
 127:  defaultPersistenceDelegate = new DefaultPersistenceDelegate();
 128:  delegates.put(Object.class, defaultPersistenceDelegate);
 129: 
 130:  // Creates a PersistenceDelegate implementation which is
 131:  // returned for 'null'. In practice this instance is
 132:  // not used in any way and is just here to be compatible
 133:  // with the reference implementation which returns a
 134:  // similar instance when calling getPersistenceDelegate(null) .
 135:  fakePersistenceDelegate = new PersistenceDelegate()
 136:  {
 137:  protected Expression instantiate(Object o, Encoder e)
 138:  {
 139:  return null;
 140:  }
 141:  };
 142: 
 143:  }
 144:  }
 145: 
 146:  protected void writeObject(Object o)
 147:  {
 148:  // 'null' has no PersistenceDelegate and will not
 149:  // create an Expression which has to be cloned.
 150:  // However subclasses should be aware that writeObject
 151:  // may be called with a 'null' argument and should
 152:  // write the proper representation of it.
 153:  if (o == null)
 154:  return;
 155: 
 156:  PersistenceDelegate pd = getPersistenceDelegate(o.getClass());
 157: 
 158:  accessCounter++;
 159:  pd.writeObject(o, this);
 160:  accessCounter--;
 161:  
 162:  }
 163: 
 164:  /**
 165:  * Sets the {@link ExceptionListener} instance to be used for reporting
 166:  * recorable exceptions in the instantiation and initialization sequence. If
 167:  * the argument is <code>null</code> a default instance will be used that
 168:  * prints the thrown exception to <code>System.err</code>.
 169:  */
 170:  public void setExceptionListener(ExceptionListener listener)
 171:  {
 172:  exceptionListener = (listener != null) 
 173:  ? listener : DefaultExceptionListener.INSTANCE;
 174:  }
 175: 
 176:  /**
 177:  * Returns the currently active {@link ExceptionListener} instance.
 178:  */
 179:  public ExceptionListener getExceptionListener()
 180:  {
 181:  return exceptionListener;
 182:  }
 183: 
 184:  public PersistenceDelegate getPersistenceDelegate(Class<?> type)
 185:  {
 186:  // This is not specified but the JDK behaves like this.
 187:  if (type == null)
 188:  return fakePersistenceDelegate;
 189: 
 190:  // Treats all array classes in the same way and assigns
 191:  // them a shared PersistenceDelegate implementation tailored
 192:  // for array instantation and initialization.
 193:  if (type.isArray())
 194:  return (PersistenceDelegate) delegates.get(Object[].class);
 195: 
 196:  PersistenceDelegate pd = (PersistenceDelegate) delegates.get(type);
 197: 
 198:  return (pd != null) ? pd : (PersistenceDelegate) defaultPersistenceDelegate;
 199:  }
 200: 
 201:  /**
 202:  * Sets the {@link PersistenceDelegate} instance for the given class.
 203:  * <p>
 204:  * Note: Throws a <code>NullPointerException</code> if the argument is
 205:  * <code>null</code>.
 206:  * </p>
 207:  * <p>
 208:  * Note: Silently ignores PersistenceDelegates for Array types and primitive
 209:  * wrapper classes.
 210:  * </p>
 211:  * <p>
 212:  * Note: Although this method is not declared <code>static</code> changes to
 213:  * the {@link PersistenceDelegate}s affect <strong>all</strong>
 214:  * {@link Encoder} instances. <strong>In this implementation</strong> the
 215:  * access is thread safe.
 216:  * </p>
 217:  */
 218:  public void setPersistenceDelegate(Class<?> type,
 219:  PersistenceDelegate delegate)
 220:  {
 221:  // If the argument is null this will cause a NullPointerException
 222:  // which is expected behavior.
 223: 
 224:  // This makes custom PDs for array, primitive types and their wrappers
 225:  // impossible but this is how the JDK behaves.
 226:  if (type.isArray() || type.isPrimitive() || type == Boolean.class
 227:  || type == Byte.class || type == Short.class || type == Integer.class
 228:  || type == Long.class || type == Float.class || type == Double.class)
 229:  return;
 230: 
 231:  synchronized (delegates)
 232:  {
 233:  delegates.put(type, delegate);
 234:  }
 235: 
 236:  }
 237: 
 238:  public Object remove(Object oldInstance)
 239:  {
 240:  return candidates.remove(oldInstance);
 241:  }
 242: 
 243:  /**
 244:  * Returns the replacement object which has been created by the encoder during
 245:  * the instantiation sequence or <code>null</code> if the object has not
 246:  * been processed yet.
 247:  * <p>
 248:  * Note: The <code>String</code> class acts as an endpoint for the
 249:  * inherently recursive algorithm of the {@link Encoder}. Therefore instances
 250:  * of <code>String</code> will always be returned by this method. In other
 251:  * words the assertion: <code>
 252:  * assert (anyEncoder.get(anyString) == anyString)
 253:  * </code<
 254:  * will always hold.</p>
 255:  *
 256:  * <p>Note: If <code>null</code> is requested, the result will
 257:  * always be <code>null</code>.</p>
 258:  */
 259:  public Object get(Object oldInstance)
 260:  {
 261:  // String instances are handled in a special way.
 262:  // No one knows why this is not officially specified
 263:  // because this is a rather important design decision.
 264:  return (oldInstance == null) ? null : 
 265:  (oldInstance.getClass() == String.class) ?
 266:  oldInstance : candidates.get(oldInstance);
 267:  }
 268: 
 269:  /**
 270:  * <p>
 271:  * Note: If you call this method not from within an object instantiation and
 272:  * initialization sequence it will be silently ignored.
 273:  * </p>
 274:  */
 275:  public void writeStatement(Statement stmt)
 276:  {
 277:  // Silently ignore out of bounds calls.
 278:  if (accessCounter <= 0)
 279:  return;
 280: 
 281:  Object target = stmt.getTarget();
 282: 
 283:  Object newTarget = get(target);
 284:  if (newTarget == null)
 285:  {
 286:  writeObject(target);
 287:  newTarget = get(target);
 288:  }
 289: 
 290:  Object[] args = stmt.getArguments();
 291:  Object[] newArgs = new Object[args.length];
 292: 
 293:  for (int i = 0; i < args.length; i++)
 294:  {
 295:  newArgs[i] = get(args[i]);
 296:  if (newArgs[i] == null || isImmutableType(args[i].getClass()))
 297:  {
 298:  writeObject(args[i]);
 299:  newArgs[i] = get(args[i]);
 300:  }
 301:  }
 302: 
 303:  Statement newStmt = new Statement(newTarget, stmt.getMethodName(), newArgs);
 304: 
 305:  try
 306:  {
 307:  newStmt.execute();
 308:  }
 309:  catch (Exception e)
 310:  {
 311:  exceptionListener.exceptionThrown(e);
 312:  }
 313: 
 314:  }
 315: 
 316:  /**
 317:  * <p>
 318:  * Note: If you call this method not from within an object instantiation and
 319:  * initialization sequence it will be silently ignored.
 320:  * </p>
 321:  */
 322:  public void writeExpression(Expression expr)
 323:  {
 324:  // Silently ignore out of bounds calls.
 325:  if (accessCounter <= 0)
 326:  return;
 327: 
 328:  Object target = expr.getTarget();
 329:  Object value = null;
 330:  Object newValue = null;
 331: 
 332:  try
 333:  {
 334:  value = expr.getValue();
 335:  }
 336:  catch (Exception e)
 337:  {
 338:  exceptionListener.exceptionThrown(e);
 339:  return;
 340:  }
 341:  
 342:  
 343:  newValue = get(value);
 344: 
 345:  if (newValue == null)
 346:  {
 347:  Object newTarget = get(target);
 348:  if (newTarget == null)
 349:  {
 350:  writeObject(target);
 351:  newTarget = get(target);
 352: 
 353:  // May happen if exception was thrown.
 354:  if (newTarget == null)
 355:  {
 356:  return;
 357:  }
 358:  }
 359: 
 360:  Object[] args = expr.getArguments();
 361:  Object[] newArgs = new Object[args.length];
 362: 
 363:  for (int i = 0; i < args.length; i++)
 364:  {
 365:  newArgs[i] = get(args[i]);
 366:  if (newArgs[i] == null || isImmutableType(args[i].getClass()))
 367:  {
 368:  writeObject(args[i]);
 369:  newArgs[i] = get(args[i]);
 370:  }
 371:  }
 372:  
 373:  Expression newExpr = new Expression(newTarget, expr.getMethodName(),
 374:  newArgs);
 375:  
 376:  // Fakes the result of Class.forName(<primitiveType>) to make it possible
 377:  // to hand such a type to the encoding process.
 378:  if (value instanceof Class && ((Class) value).isPrimitive())
 379:  newExpr.setValue(value);
 380:  
 381:  // Instantiates the new object.
 382:  try
 383:  {
 384:  newValue = newExpr.getValue();
 385: 
 386:  candidates.put(value, newValue);
 387:  }
 388:  catch (Exception e)
 389:  {
 390:  exceptionListener.exceptionThrown(e);
 391:  
 392:  return;
 393:  }
 394:  
 395:  writeObject(value);
 396: 
 397:  }
 398:  else if(value.getClass() == String.class || value.getClass() == Class.class)
 399:  {
 400:  writeObject(value);
 401:  }
 402: 
 403:  }
 404: 
 405:  /** Returns whether the given class is an immutable
 406:  * type which has to be handled differently when serializing it.
 407:  * 
 408:  * <p>Immutable objects always have to be instantiated instead of
 409:  * modifying an existing instance.</p>
 410:  * 
 411:  * @param type The class to test.
 412:  * @return Whether the first argument is an immutable type.
 413:  */
 414:  boolean isImmutableType(Class type)
 415:  {
 416:  return type == String.class || type == Class.class
 417:  || type == Integer.class || type == Boolean.class
 418:  || type == Byte.class || type == Short.class
 419:  || type == Long.class || type == Float.class
 420:  || type == Double.class;
 421:  }
 422:  
 423:  /** Sets the stream candidate for a given object.
 424:  * 
 425:  * @param oldObject The object given to the encoder.
 426:  * @param newObject The object the encoder generated.
 427:  */
 428:  void putCandidate(Object oldObject, Object newObject)
 429:  {
 430:  candidates.put(oldObject, newObject);
 431:  }
 432:  
 433: }