Source for javax.naming.Reference

 1:  /* Reference.java --
 2:  Copyright (C) 2000, 2001, 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 javax.naming;
 40: 
 41:  import java.io.Serializable;
 42:  import java.util.Enumeration;
 43:  import java.util.Vector;
 44: 
 45:  /**
 46:  * This class represents a reference to an object that is located outside of the
 47:  * naming/directory system.
 48:  * 
 49:  * @see Referenceable
 50:  * 
 51:  * @author Tom Tromey (tromey@redhat.com)
 52:  */
 53:  public class Reference implements Cloneable, Serializable
 54: {
 55:  private static final long serialVersionUID = - 1673475790065791735L;
 56:  
 57:  /**
 58:  * The list of addresses, stored in this reference. The object may be 
 59:  * have by several different addresses.
 60:  */
 61:  protected Vector<RefAddr> addrs;
 62:  
 63:  /**
 64:  * The name of the class factory to create an instance of the object,
 65:  * referenced by this reference.
 66:  */
 67:  protected String classFactory;
 68:  
 69:  /**
 70:  * The location, from where the class factory should be loaded.
 71:  */
 72:  protected String classFactoryLocation;
 73:  
 74:  /**
 75:  * The name of the class of the object, to that this reference refers.
 76:  */
 77:  protected String className;
 78:  
 79:  /**
 80:  * Create a new reference that is referencting to the object of the
 81:  * specified class.
 82:  */
 83:  public Reference (String className)
 84:  {
 85:  this.className = className;
 86:  addrs = new Vector<RefAddr> ();
 87:  }
 88:  
 89:  /**
 90:  * Create a new reference that is referencing to the object of the
 91:  * specified class with the given address.
 92:  */
 93:  public Reference (String className, RefAddr addr)
 94:  {
 95:  this.className = className;
 96:  addrs = new Vector<RefAddr> ();
 97:  addrs.add (addr);
 98:  }
 99:  
 100:  /**
 101:  * Create a new reference that is referencing to the object of the
 102:  * specified class, specifying the class and location of the factory that
 103:  * produces these objects.
 104:  * 
 105:  * @param className the object class name
 106:  * @param factoryClassName the object factory class name
 107:  * @param factoryLocation the object factory location
 108:  */
 109:  public Reference (String className, String factoryClassName, 
 110:  String factoryLocation)
 111:  {
 112:  this.className = className;
 113:  this.classFactory = factoryClassName;
 114:  this.classFactoryLocation = factoryLocation;
 115:  addrs = new Vector<RefAddr> ();
 116:  }
 117: 
 118:  /**
 119:  * Create a new reference that is referencing to the object of the
 120:  * specified class, specifying the class and location of the factory that
 121:  * produces these objects and also the address of this object.
 122:  * 
 123:  * @param className the object class name
 124:  * @param addr the address of the object
 125:  * @param factoryClassName the object factory class name
 126:  * @param factoryLocation the object factory location
 127:  */
 128:  public Reference (String className, RefAddr addr,
 129:  String factoryClassName, String factoryLocation)
 130:  {
 131:  this.className = className;
 132:  this.classFactory = factoryClassName;
 133:  this.classFactoryLocation = factoryLocation;
 134:  addrs = new Vector<RefAddr> ();
 135:  addrs.add (addr);
 136:  }
 137: 
 138:  /**
 139:  * Add the new address for this object at the given position of the 
 140:  * address list.
 141:  */
 142:  public void add (int posn, RefAddr addr)
 143:  {
 144:  addrs.add (posn, addr);
 145:  }
 146:  
 147:  /**
 148:  * Appends the new object address to the end of the address list.
 149:  */
 150:  public void add (RefAddr addr)
 151:  {
 152:  addrs.add (addr);
 153:  }
 154:  
 155:  /**
 156:  * Removes all defined addresses of the object.
 157:  */
 158:  public void clear ()
 159:  {
 160:  addrs.clear ();
 161:  }
 162: 
 163:  public Object clone ()
 164:  {
 165:  Reference r = new Reference (className, classFactory,
 166:  classFactoryLocation);
 167:  r.addrs = (Vector<RefAddr>) addrs.clone ();
 168:  return r;
 169:  }
 170: 
 171:  // Convenience function.
 172:  private boolean equals (String a, String b)
 173:  {
 174:  return (a == null) ? (b == null) : a.equals (b);
 175:  }
 176:  
 177:  /**
 178:  * Compares two addresses for equality, by value.
 179:  */
 180:  public boolean equals (Object obj)
 181:  {
 182:  if (! (obj instanceof Reference))
 183:  return false;
 184:  Reference r = (Reference) obj;
 185:  return (equals (classFactory, r.classFactory)
 186:  && equals (classFactoryLocation, r.classFactoryLocation)
 187:  && equals (className, r.className)
 188:  && addrs.equals (r.addrs));
 189:  }
 190:  
 191:  /**
 192:  * Get the address of this object at the given position.
 193:  */
 194:  public RefAddr get (int posn)
 195:  {
 196:  return addrs.get (posn);
 197:  }
 198:  
 199:  /**
 200:  * Get the given type of address for this object.
 201:  * 
 202:  * @param addrType the needed type of address
 203:  * 
 204:  * @return the address of this object, having the specified type. If there
 205:  * is no address of such type, null is returned.
 206:  */
 207:  public RefAddr get (String addrType)
 208:  {
 209:  for (int i = 0; i < addrs.size (); ++i)
 210:  {
 211:  RefAddr r = addrs.get (i);
 212:  if (addrType.equals (r.getType ()))
 213:  return r;
 214:  }
 215:  return null;
 216:  }
 217:  
 218:  /**
 219:  * Get the enumeration over all defined addresses of the object.
 220:  */
 221:  public Enumeration<RefAddr> getAll ()
 222:  {
 223:  return addrs.elements ();
 224:  }
 225:  
 226:  /**
 227:  * Get the name of the class of the referenced object.
 228:  * 
 229:  * @see #className
 230:  */
 231:  public String getClassName ()
 232:  {
 233:  return className;
 234:  }
 235:  
 236:  /**
 237:  * Get the location of the factory class of the referenced object.
 238:  * 
 239:  * @see #classFactoryLocation
 240:  */
 241:  public String getFactoryClassLocation ()
 242:  {
 243:  return classFactoryLocation;
 244:  }
 245: 
 246:  /**
 247:  * Get the name of the factory class of the referenced object
 248:  * 
 249:  * @see #classFactory
 250:  */
 251:  public String getFactoryClassName ()
 252:  {
 253:  return classFactory;
 254:  }
 255:  
 256:  /**
 257:  * Get the hashcode of this reference. 
 258:  * 
 259:  * @return the sum of the hash codes of the addresses. 
 260:  */
 261:  public int hashCode ()
 262:  {
 263:  // The spec says the hash code is the sum of the hash codes of the
 264:  // addresses. It does not mention the other fields.
 265:  int h = 0;
 266:  for (int i = 0; i < addrs.size (); ++i)
 267:  h += addrs.get (i).hashCode ();
 268:  return h;
 269:  }
 270:  
 271:  /**
 272:  * Remove the address at the given position.
 273:  * 
 274:  * @param posn the position of the address to remove
 275:  * 
 276:  * @return the removed address
 277:  */
 278:  public Object remove (int posn)
 279:  {
 280:  return addrs.remove (posn);
 281:  }
 282:  
 283:  /**
 284:  * Return the number of the defined addresses.
 285:  */
 286:  public int size ()
 287:  {
 288:  return addrs.size ();
 289:  }
 290:  
 291:  /**
 292:  * Return the string representation.
 293:  */
 294:  public String toString ()
 295:  {
 296:  String x = getClass ().toString () + "[";
 297:  for (int i = 0; i < addrs.size (); ++i)
 298:  {
 299:  if (i > 0)
 300:  x += ",";
 301:  x += addrs.get (i).toString ();
 302:  }
 303:  return x + "]";
 304:  }
 305: 
 306: }