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