001/* AttributeSetUtilities.java -- 002 Copyright (C) 2003, 2004, 2006 Free Software Foundation, Inc. 003 004This file is part of GNU Classpath. 005 006GNU Classpath is free software; you can redistribute it and/or modify 007it under the terms of the GNU General Public License as published by 008the Free Software Foundation; either version 2, or (at your option) 009any later version. 010 011GNU Classpath is distributed in the hope that it will be useful, but 012WITHOUT ANY WARRANTY; without even the implied warranty of 013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014General Public License for more details. 015 016You should have received a copy of the GNU General Public License 017along with GNU Classpath; see the file COPYING. If not, write to the 018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 01902110-1301 USA. 020 021Linking this library statically or dynamically with other modules is 022making a combined work based on this library. Thus, the terms and 023conditions of the GNU General Public License cover the whole 024combination. 025 026As a special exception, the copyright holders of this library give you 027permission to link this library with independent modules to produce an 028executable, regardless of the license terms of these independent 029modules, and to copy and distribute the resulting executable under 030terms of your choice, provided that you also meet, for each linked 031independent module, the terms and conditions of the license of that 032module. An independent module is a module which is not derived from 033or based on this library. If you modify this library, you may extend 034this exception to your version of the library, but you are not 035obligated to do so. If you do not wish to do so, delete this 036exception statement from your version. */ 037 038package javax.print.attribute; 039 040import java.io.Serializable; 041 042/** 043 * <code>AttributeSetUtilities</code> provides static methods for working 044 * with <code>AttributeSet</code>s. 045 * <p> 046 * For every type of an attribute set available in the Java Print Service API 047 * are methods provided to get an unmodifiable view of an attribute set. 048 * This unmodifiable view provides a read-only version of the attribute 049 * set which throws {@link javax.print.attribute.UnmodifiableSetException}s 050 * if state changing methods are invoked. 051 * </p> 052 * <p> 053 * Methods for getting a synchronized view of an attribute set are also 054 * available. This view provides synchronized (thread safe) access to the 055 * underlying wrapped attribute set. 056 * </P> 057 * <p> 058 * Three static methods for the implementation of own AttributeSets 059 * are provided, which verify that: 060 * <ul> 061 * <li>the given object is an attribute of the given interface.</li> 062 * <li>the category of given attribute is equals to a given category.</li> 063 * <li>the given object is a <code>Class</code> that implements the given 064 * interface name.</li> 065 * </ul> 066 * 067 */ 068public final class AttributeSetUtilities 069{ 070 /** 071 * This class isn't intended to be instantiated. 072 */ 073 private AttributeSetUtilities() 074 { 075 // only static methods 076 } 077 078 private static class UnmodifiableAttributeSet 079 implements AttributeSet, Serializable 080 { 081 private AttributeSet attrset; 082 083 public UnmodifiableAttributeSet(AttributeSet attributeSet) 084 { 085 if (attributeSet == null) 086 throw new NullPointerException("attributeSet may not be null"); 087 088 this.attrset = attributeSet; 089 } 090 091 public boolean add(Attribute attribute) 092 { 093 throw new UnmodifiableSetException(); 094 } 095 096 public boolean addAll(AttributeSet attributes) 097 { 098 throw new UnmodifiableSetException(); 099 } 100 101 public void clear() 102 { 103 throw new UnmodifiableSetException(); 104 } 105 106 public boolean containsKey(Class category) 107 { 108 return attrset.containsKey(category); 109 } 110 111 public boolean containsValue(Attribute attribute) 112 { 113 return attrset.containsValue(attribute); 114 } 115 116 public boolean equals(Object obj) 117 { 118 return attrset.equals(obj); 119 } 120 121 public Attribute get(Class interfaceName) 122 { 123 return attrset.get(interfaceName); 124 } 125 126 public int hashCode() 127 { 128 return attrset.hashCode(); 129 } 130 131 public boolean isEmpty() 132 { 133 return attrset.isEmpty(); 134 } 135 136 public boolean remove(Class category) 137 { 138 throw new UnmodifiableSetException(); 139 } 140 141 public boolean remove(Attribute attribute) 142 { 143 throw new UnmodifiableSetException(); 144 } 145 146 public int size() 147 { 148 return attrset.size(); 149 } 150 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 { 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 { 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 { 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 { 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 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 210 public synchronized boolean add(Attribute attribute) 211 { 212 return attrset.add(attribute); 213 } 214 215 public synchronized boolean addAll(AttributeSet attributes) 216 { 217 return attrset.addAll(attributes); 218 } 219 220 public synchronized void clear() 221 { 222 attrset.clear(); 223 } 224 225 public synchronized boolean containsKey(Class category) 226 { 227 return attrset.containsKey(category); 228 } 229 230 public synchronized boolean containsValue(Attribute attribute) 231 { 232 return attrset.containsValue(attribute); 233 } 234 235 public synchronized boolean equals(Object obj) 236 { 237 return attrset.equals(obj); 238 } 239 240 public synchronized Attribute get(Class interfaceName) 241 { 242 return attrset.get(interfaceName); 243 } 244 245 public synchronized int hashCode() 246 { 247 return attrset.hashCode(); 248 } 249 250 public synchronized boolean isEmpty() 251 { 252 return attrset.isEmpty(); 253 } 254 255 public synchronized boolean remove(Class category) 256 { 257 return attrset.remove(category); 258 } 259 260 public synchronized boolean remove(Attribute attribute) 261 { 262 return attrset.remove(attribute); 263 } 264 265 public synchronized int size() 266 { 267 return attrset.size(); 268 } 269 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 { 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 { 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 { 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 { 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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}