libjava/javax/print/attribute/AttributeSetUtilities.java

   1 /* AttributeSetUtilities.java --
   2    Copyright (C) 2003, 2004  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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 package javax.print.attribute;
  39
  40 import java.io.Serializable;
  41
  42 public final class AttributeSetUtilities
  43 {
  44   private static class UnmodifiableAttributeSet
  45     implements AttributeSet, Serializable
  46   {
  47     private AttributeSet set;
  48
  49     public UnmodifiableAttributeSet(AttributeSet attributeSet)
  50     {
  51       if (attributeSet == null)
  52         throw new NullPointerException("attributeSet may not be null");
  53
  54       this.set = attributeSet;
  55     }
  56
  57     public boolean add(Attribute attribute)
  58     {
  59       throw new UnmodifiableSetException();
  60     }
  61
  62     public boolean addAll(AttributeSet attributes)
  63     {
  64       throw new UnmodifiableSetException();
  65     }
  66
  67     public void clear()
  68     {
  69       throw new UnmodifiableSetException();
  70     }
  71
  72     public boolean containsKey(Class category)
  73     {
  74       return set.containsKey(category);
  75     }
  76
  77     public boolean containsValue(Attribute attribute)
  78     {
  79       return set.containsValue(attribute);
  80     }
  81
  82     public boolean equals(Object obj)
  83     {
  84       return set.equals(obj);
  85     }
  86
  87     public Attribute get(Class interfaceName)
  88     {
  89       return set.get(interfaceName);
  90     }
  91
  92     public int hashCode()
  93     {
  94       return set.hashCode();
  95     }
  96
  97     public boolean isEmpty()
  98     {
  99       return set.isEmpty();
 100     }
 101
 102     public boolean remove(Class category)
 103     {
 104       throw new UnmodifiableSetException();
 105     }
 106
 107     public boolean remove(Attribute attribute)
 108     {
 109       throw new UnmodifiableSetException();
 110     }
 111
 112     public int size()
 113     {
 114       return set.size();
 115     }
 116
 117     public Attribute[] toArray()
 118     {
 119       return set.toArray();
 120     }
 121   }
 122
 123   public static class UnmodifiableDocAttributeSet
 124     extends UnmodifiableAttributeSet
 125     implements DocAttributeSet, Serializable
 126   {
 127     public UnmodifiableDocAttributeSet(DocAttributeSet attributeSet)
 128     {
 129       super(attributeSet);
 130     }
 131   }
 132
 133   public static class UnmodifiablePrintJobAttributeSet
 134     extends UnmodifiableAttributeSet
 135     implements PrintJobAttributeSet, Serializable
 136   {
 137     public UnmodifiablePrintJobAttributeSet(PrintJobAttributeSet attributeSet)
 138     {
 139       super(attributeSet);
 140     }
 141   }
 142
 143   public static class UnmodifiablePrintRequestAttributeSet
 144     extends UnmodifiableAttributeSet
 145     implements PrintRequestAttributeSet, Serializable
 146   {
 147     public UnmodifiablePrintRequestAttributeSet(PrintRequestAttributeSet attributeSet)
 148     {
 149       super(attributeSet);
 150     }
 151   }
 152
 153   public static class UnmodifiablePrintServiceAttributeSet
 154     extends UnmodifiableAttributeSet
 155     implements PrintServiceAttributeSet, Serializable
 156   {
 157     public UnmodifiablePrintServiceAttributeSet(PrintServiceAttributeSet attributeSet)
 158     {
 159       super(attributeSet);
 160     }
 161   }
 162
 163   public static class SynchronizedAttributeSet
 164     implements AttributeSet, Serializable
 165   {
 166     private AttributeSet set;
 167
 168     public SynchronizedAttributeSet(AttributeSet attributeSet)
 169     {
 170       if (attributeSet == null)
 171         throw new NullPointerException("attributeSet may not be null");
 172
 173       this.set = attributeSet;
 174     }
 175
 176     public synchronized boolean add(Attribute attribute)
 177     {
 178       return set.add(attribute);
 179     }
 180
 181     public synchronized boolean addAll(AttributeSet attributes)
 182     {
 183       return set.addAll(attributes);
 184     }
 185
 186     public synchronized void clear()
 187     {
 188       set.clear();
 189     }
 190
 191     public synchronized boolean containsKey(Class category)
 192     {
 193       return set.containsKey(category);
 194     }
 195
 196     public synchronized boolean containsValue(Attribute attribute)
 197     {
 198       return set.containsValue(attribute);
 199     }
 200
 201     public synchronized boolean equals(Object obj)
 202     {
 203       return set.equals(obj);
 204     }
 205
 206     public synchronized Attribute get(Class interfaceName)
 207     {
 208       return set.get(interfaceName);
 209     }
 210
 211     public synchronized int hashCode()
 212     {
 213       return set.hashCode();
 214     }
 215
 216     public synchronized boolean isEmpty()
 217     {
 218       return set.isEmpty();
 219     }
 220
 221     public synchronized boolean remove(Class category)
 222     {
 223       return set.remove(category);
 224     }
 225
 226     public synchronized boolean remove(Attribute attribute)
 227     {
 228       return set.remove(attribute);
 229     }
 230
 231     public synchronized int size()
 232     {
 233       return set.size();
 234     }
 235
 236     public synchronized Attribute[] toArray()
 237     {
 238       return set.toArray();
 239     }
 240   }
 241
 242   public static class SynchronizedDocAttributeSet
 243     extends SynchronizedAttributeSet
 244     implements DocAttributeSet, Serializable
 245   {
 246     public SynchronizedDocAttributeSet(DocAttributeSet attributeSet)
 247     {
 248       super(attributeSet);
 249     }
 250   }
 251
 252   public static class SynchronizedPrintJobAttributeSet
 253     extends SynchronizedAttributeSet
 254     implements PrintJobAttributeSet, Serializable
 255   {
 256     public SynchronizedPrintJobAttributeSet(PrintJobAttributeSet attributeSet)
 257     {
 258       super(attributeSet);
 259     }
 260   }
 261
 262   public static class SynchronizedPrintRequestAttributeSet
 263     extends SynchronizedAttributeSet
 264     implements PrintRequestAttributeSet, Serializable
 265   {
 266     public SynchronizedPrintRequestAttributeSet(PrintRequestAttributeSet attributeSet)
 267     {
 268       super(attributeSet);
 269     }
 270   }
 271
 272   public static class SynchronizedPrintServiceAttributeSet
 273     extends SynchronizedAttributeSet
 274     implements PrintServiceAttributeSet, Serializable
 275   {
 276     public SynchronizedPrintServiceAttributeSet(PrintServiceAttributeSet attributeSet)
 277     {
 278       super(attributeSet);
 279     }
 280   }
 281
 282   /**
 283    * Returns a synchronized view of the given attribute set.
 284    *
 285    * @return the sychronized attribute set
 286    */
 287   public static AttributeSet synchronizedView(AttributeSet attributeSet)
 288   {
 289     return new SynchronizedAttributeSet(attributeSet);
 290   }
 291
 292   /**
 293    * Returns a synchronized view of the given attribute set.
 294    *
 295    * @return the sychronized attribute set
 296    */
 297   public static DocAttributeSet synchronizedView(DocAttributeSet attributeSet)
 298   {
 299     return new SynchronizedDocAttributeSet(attributeSet);
 300   }
 301
 302   /**
 303    * Returns a synchronized view of the given attribute set.
 304    *
 305    * @return the sychronized attribute set
 306    */
 307   public static PrintJobAttributeSet synchronizedView(PrintJobAttributeSet attributeSet)
 308   {
 309     return new SynchronizedPrintJobAttributeSet(attributeSet);
 310   }
 311
 312   /**
 313    * Returns a synchronized view of the given attribute set.
 314    *
 315    * @return the sychronized attribute set
 316    */
 317   public static PrintRequestAttributeSet synchronizedView(PrintRequestAttributeSet attributeSet)
 318   {
 319     return new SynchronizedPrintRequestAttributeSet(attributeSet);
 320   }
 321
 322   /**
 323    * Returns a synchronized view of the given attribute set.
 324    *
 325    * @return the sychronized attribute set
 326    */
 327   public static PrintServiceAttributeSet synchronizedView(PrintServiceAttributeSet attributeSet)
 328   {
 329     return new SynchronizedPrintServiceAttributeSet(attributeSet);
 330   }
 331
 332   /**
 333    * Returns an unmodifiable view of the given attribute set.
 334    *
 335    * @return the sychronized attribute set
 336    */
 337   public static AttributeSet unmodifiableView(AttributeSet attributeSet)
 338   {
 339     return new UnmodifiableAttributeSet(attributeSet);
 340   }
 341
 342   /**
 343    * Returns an unmodifiable view of the given attribute set.
 344    *
 345    * @return the sychronized attribute set
 346    */
 347   public static DocAttributeSet unmodifiableView(DocAttributeSet attributeSet)
 348   {
 349     return new UnmodifiableDocAttributeSet(attributeSet);
 350   }
 351
 352   /**
 353    * Returns an unmodifiable view of the given attribute set.
 354    *
 355    * @return the sychronized attribute set
 356    */
 357   public static PrintJobAttributeSet unmodifiableView(PrintJobAttributeSet attributeSet)
 358   {
 359     return new UnmodifiablePrintJobAttributeSet(attributeSet);
 360   }
 361
 362   /**
 363    * Returns an unmodifiable view of the given attribute set.
 364    *
 365    * @return the sychronized attribute set
 366    */
 367   public static PrintRequestAttributeSet unmodifiableView(PrintRequestAttributeSet attributeSet)
 368   {
 369     return new UnmodifiablePrintRequestAttributeSet(attributeSet);
 370   }
 371
 372   /**
 373    * Returns an unmodifiable view of the given attribute set.
 374    *
 375    * @return the sychronized attribute set
 376    */
 377   public static PrintServiceAttributeSet unmodifiableView(PrintServiceAttributeSet attributeSet)
 378   {
 379     return new UnmodifiablePrintServiceAttributeSet(attributeSet);
 380   }
 381
 382   /**
 383    * Verifies that the given object is a <code>Class</code> that
 384    * implements the given interface name.
 385    *
 386    * @return object casted to <code>Class</code>
 387    *
 388    * @exception ClassCastException if object is not a <code>Class</code>
 389    * that implements interfaceName
 390    * @exception NullPointerException if object is null
 391    */
 392   public static Class verifyAttributeCategory(Object object,
 393                                               Class interfaceName)
 394   {
 395     if (object == null)
 396       throw new NullPointerException("object may not be null");
 397
 398     Class clazz = (Class) object;
 399
 400     if (interfaceName.isAssignableFrom(clazz))
 401       return clazz;
 402
 403     throw new ClassCastException();
 404   }
 405
 406   /**
 407    * Verifies that the given object is an attribute of the given interface.
 408    *
 409    * @return the object casted to <code>Attribute</code>
 410    *
 411    * @exception ClassCastException if object is no instance of interfaceName.
 412    * @exception NullPointerException if object is null
 413    */
 414   public static Attribute verifyAttributeValue(Object object,
 415                                                Class interfaceName)
 416   {
 417     if (object == null)
 418       throw new NullPointerException("object may not be null");
 419
 420     if (interfaceName.isInstance(object))
 421       return (Attribute) object;
 422
 423     throw new ClassCastException();
 424   }
 425
 426   /**
 427    * Verifies that the category of attribute is equals to category.
 428    *
 429    * @param category the category the atteribute should be
 430    * @param attribute the attribute to verify
 431    *
 432    * @exception IllegalArgumentException if the categories are not equal
 433    * @exception NullPointerException if category is null
 434    */
 435   public static void verifyCategoryForValue(Class category,
 436                                             Attribute attribute)
 437   {
 438     if (category == null)
 439       throw new NullPointerException("object may not be null");
 440
 441     if (category.equals(attribute.getCategory()))
 442       throw new IllegalArgumentException
 443         ("category of attribute not equal to category");
 444   }
 445 }