API Overview API Index Package Overview Direct link to this page
JDK 1.6
  javax.print.attribute. AttributeSetUtilities View Javadoc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560

/*
 * @(#)AttributeSetUtilities.java	1.11 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */


package javax.print.attribute;

import java.io.Serializable;

/**
 * Class AttributeSetUtilities provides static methods for manipulating
 * AttributeSets.
 * <ul>
 * <li>Methods for creating unmodifiable and synchronized views of attribute
 * sets. 
 * <li>operations useful for building 
 * implementations of interface {@link AttributeSet AttributeSet}
 * </ul>
 * <P>
 * An <B>unmodifiable view</B> <I>U</I> of an AttributeSet <I>S</I> provides a 
 * client with "read-only" access to <I>S</I>. Query operations on <I>U</I> 
 * "read through" to <I>S</I>; thus, changes in <I>S</I> are reflected in 
 * <I>U</I>. However, any attempt to modify <I>U</I>,
 *  results in an UnmodifiableSetException.
 * The unmodifiable view object <I>U</I> will be serializable if the
 * attribute set object <I>S</I> is serializable. 
 * <P>
 * A <B>synchronized view</B> <I>V</I> of an attribute set <I>S</I> provides a 
 * client with synchronized (multiple thread safe) access to <I>S</I>. Each 
 * operation of <I>V</I> is synchronized using <I>V</I> itself as the lock 
 * object and then merely invokes the corresponding operation of <I>S</I>. In 
 * order to guarantee mutually exclusive access, it is critical that all
 * access to <I>S</I> is accomplished through <I>V</I>. The synchronized view
 * object <I>V</I> will be serializable if the attribute set object <I>S</I>
 * is serializable. 
 * <P>
 * As mentioned in the package description of javax.print, a null reference 
 * parameter to methods is 
 * incorrect unless explicitly documented on the method as having a meaningful
 * interpretation.  Usage to the contrary is incorrect coding and may result in 
 * a run time exception either immediately 
 * or at some later time. IllegalArgumentException and NullPointerException 
 * are examples of typical and acceptable run time exceptions for such cases.
 *
 * @author  Alan Kaminsky
 */
public final class AttributeSetUtilities {

    /* Suppress default constructor, ensuring non-instantiability.
     */
    private AttributeSetUtilities() {
    }

    /**
      * @serial include
      */
    private static class UnmodifiableAttributeSet 
	implements AttributeSet, Serializable {
	
	private AttributeSet attrset;	

	/* Unmodifiable view of the underlying attribute set. 
	 */
	public UnmodifiableAttributeSet(AttributeSet attributeSet) {

	    attrset = attributeSet;
	}

	public Attribute get(Class<?> key) {
	    return attrset.get(key);
	}

	public boolean add(Attribute attribute) {
	    throw new UnmodifiableSetException();
	}

	public synchronized boolean remove(Class<?> category) {
	    throw new UnmodifiableSetException();
	}

	public boolean remove(Attribute attribute) {
	    throw new UnmodifiableSetException();
	}

	public boolean containsKey(Class<?> category) {
	    return attrset.containsKey(category);
	}
	
	public boolean containsValue(Attribute attribute) {
	    return attrset.containsValue(attribute);
	}
	
	public boolean addAll(AttributeSet attributes) {
	    throw new UnmodifiableSetException();
	}

	public int size() {
	    return attrset.size();
	}

	public Attribute[] toArray() {
	    return attrset.toArray();
	}
	
	public void clear() {
	    throw new UnmodifiableSetException();
	}

	public boolean isEmpty() {
	    return attrset.isEmpty();
	}

	public boolean equals(Object o) {
	    return attrset.equals (o);
	}

	public int hashCode() {
	    return attrset.hashCode();
	}

    }

    /**
      * @serial include
      */
    private static class UnmodifiableDocAttributeSet
	extends UnmodifiableAttributeSet
	implements DocAttributeSet, Serializable {

	public UnmodifiableDocAttributeSet(DocAttributeSet attributeSet) {

	    super (attributeSet);
	}
    }
    
    /**
      * @serial include
      */
    private static class UnmodifiablePrintRequestAttributeSet
	extends UnmodifiableAttributeSet
	implements PrintRequestAttributeSet, Serializable
    {
	public UnmodifiablePrintRequestAttributeSet
	    (PrintRequestAttributeSet attributeSet) {

	    super (attributeSet);
	}
    }

    /**
      * @serial include
      */
    private static class UnmodifiablePrintJobAttributeSet
	extends UnmodifiableAttributeSet
	implements PrintJobAttributeSet, Serializable
    {
	public UnmodifiablePrintJobAttributeSet
	    (PrintJobAttributeSet attributeSet)	{

	    super (attributeSet);
	}
    }

    /**
      * @serial include
      */
    private static class UnmodifiablePrintServiceAttributeSet
	extends UnmodifiableAttributeSet
	implements PrintServiceAttributeSet, Serializable
    {
	public UnmodifiablePrintServiceAttributeSet
	    (PrintServiceAttributeSet attributeSet) {

	    super (attributeSet);
	}
    }

    /**
     * Creates an unmodifiable view of the given attribute set.
     *
     * @param  attributeSet  Underlying attribute set.
     *
     * @return  Unmodifiable view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null. Null is never a
     */
    public static AttributeSet unmodifiableView(AttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}

	return new UnmodifiableAttributeSet(attributeSet);
    }

    /**
     * Creates an unmodifiable view of the given doc attribute set.
     *
     * @param  attributeSet  Underlying doc attribute set.
     *
     * @return  Unmodifiable view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static DocAttributeSet unmodifiableView
	(DocAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new UnmodifiableDocAttributeSet(attributeSet);
    }
    
    /**
     * Creates an unmodifiable view of the given print request attribute set.
     *
     * @param  attributeSet  Underlying print request attribute set.
     *
     * @return  Unmodifiable view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static PrintRequestAttributeSet 
	unmodifiableView(PrintRequestAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new UnmodifiablePrintRequestAttributeSet(attributeSet);
    }
    
    /**
     * Creates an unmodifiable view of the given print job attribute set.
     *
     * @param  attributeSet  Underlying print job attribute set.
     *
     * @return  Unmodifiable view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static PrintJobAttributeSet 
	unmodifiableView(PrintJobAttributeSet attributeSet) {
    	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new UnmodifiablePrintJobAttributeSet(attributeSet);
    }
    
    /**
     * Creates an unmodifiable view of the given print service attribute set.
     *
     * @param  attributeSet  Underlying print service attribute set.
     *
     * @return  Unmodifiable view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static PrintServiceAttributeSet
	unmodifiableView(PrintServiceAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new UnmodifiablePrintServiceAttributeSet (attributeSet);
    }

    /**
      * @serial include
      */
    private static class SynchronizedAttributeSet	
                   	implements AttributeSet, Serializable {
    
	private AttributeSet attrset;
    	
	public SynchronizedAttributeSet(AttributeSet attributeSet) {
	    attrset = attributeSet;
	}

	public synchronized Attribute get(Class<?> category) {
	    return attrset.get(category);
	}

	public synchronized boolean add(Attribute attribute) {
	    return attrset.add(attribute);
	}

	public synchronized boolean remove(Class<?> category) {
	    return attrset.remove(category);
	}

	public synchronized boolean remove(Attribute attribute) {
	    return attrset.remove(attribute);
	}

	public synchronized boolean containsKey(Class<?> category) {
	    return attrset.containsKey(category);
	}
		
	public synchronized boolean containsValue(Attribute attribute) {
	    return attrset.containsValue(attribute);
	}
	
	public synchronized boolean addAll(AttributeSet attributes) {
	    return attrset.addAll(attributes);
	}

	public synchronized int size() {
	    return attrset.size();
	}

	public synchronized Attribute[] toArray() {
	    return attrset.toArray();
	}
	
	public synchronized void clear() {
	    attrset.clear();
	}

	public synchronized boolean isEmpty() {
	    return attrset.isEmpty();
	}

	public synchronized boolean equals(Object o) {
	    return attrset.equals (o);
	}

	public synchronized int hashCode() {
	    return attrset.hashCode();
	}
    }
    
    /**
      * @serial include
      */
    private static class SynchronizedDocAttributeSet
	extends SynchronizedAttributeSet
	implements DocAttributeSet, Serializable {

	public SynchronizedDocAttributeSet(DocAttributeSet attributeSet) {
	    super(attributeSet);
	}
    }

    /**
      * @serial include
      */
    private static class SynchronizedPrintRequestAttributeSet
	extends SynchronizedAttributeSet
	implements PrintRequestAttributeSet, Serializable {
	
	public SynchronizedPrintRequestAttributeSet
	    (PrintRequestAttributeSet attributeSet) {
	    super(attributeSet);
	}
    }

    /**
      * @serial include
      */
    private static class SynchronizedPrintJobAttributeSet
	extends SynchronizedAttributeSet
	implements PrintJobAttributeSet, Serializable {

	public SynchronizedPrintJobAttributeSet
	    (PrintJobAttributeSet attributeSet)	{
	    super(attributeSet);
	}
    }

    /**
      * @serial include
      */
    private static class SynchronizedPrintServiceAttributeSet
	extends SynchronizedAttributeSet
	implements PrintServiceAttributeSet, Serializable {
	public SynchronizedPrintServiceAttributeSet
	    (PrintServiceAttributeSet attributeSet) {
	    super(attributeSet);
	}
    }
        
    /**
     * Creates a synchronized view of the given attribute set.
     *
     * @param  attributeSet  Underlying attribute set.
     *
     * @return  Synchronized view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static AttributeSet synchronizedView
	(AttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new SynchronizedAttributeSet(attributeSet);
    }
  
    /**
     * Creates a synchronized view of the given doc attribute set.
     *
     * @param  attributeSet  Underlying doc attribute set.
     *
     * @return  Synchronized view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static DocAttributeSet
	synchronizedView(DocAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new SynchronizedDocAttributeSet(attributeSet);
    }
    
    /**
     * Creates a synchronized view of the given print request attribute set.
     *
     * @param  attributeSet  Underlying print request attribute set.
     *
     * @return  Synchronized view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static PrintRequestAttributeSet 
	synchronizedView(PrintRequestAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new SynchronizedPrintRequestAttributeSet(attributeSet);
    }

    /**
     * Creates a synchronized view of the given print job attribute set.
     *
     * @param  attributeSet  Underlying print job attribute set.
     *
     * @return  Synchronized view of <CODE>attributeSet</CODE>.
     *
     * @exception  NullPointerException
     *     Thrown if <CODE>attributeSet</CODE> is null.
     */
    public static PrintJobAttributeSet
	synchronizedView(PrintJobAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new SynchronizedPrintJobAttributeSet(attributeSet);
    }

    /**
     * Creates a synchronized view of the given print service attribute set.
     *
     * @param  attributeSet  Underlying print service attribute set.
     *
     * @return  Synchronized view of <CODE>attributeSet</CODE>.
     */
    public static PrintServiceAttributeSet
	synchronizedView(PrintServiceAttributeSet attributeSet) {
	if (attributeSet == null) {
	    throw new NullPointerException();
	}
	return new SynchronizedPrintServiceAttributeSet(attributeSet);
    }
    

    /**
     * Verify that the given object is a {@link java.lang.Class Class} that 
     * implements the given interface, which is assumed to be interface {@link 
     * Attribute Attribute} or a subinterface thereof. 
     *
     * @param  object     Object to test.
     * @param  interfaceName  Interface the object must implement.
     *
     * @return  If <CODE>object</CODE> is a {@link java.lang.Class Class}
     *          that implements <CODE>interfaceName</CODE>, 
     *          <CODE>object</CODE> is returned downcast to type {@link 
     *          java.lang.Class Class}; otherwise an exception is thrown. 
     *
     * @exception  NullPointerException
     *     (unchecked exception) Thrown if <CODE>object</CODE> is null.
     * @exception  ClassCastException
     *     (unchecked exception) Thrown if <CODE>object</CODE> is not a 
     *     {@link java.lang.Class Class} that implements 
     *     <CODE>interfaceName</CODE>. 
     */
    public static Class<?>
	verifyAttributeCategory(Object object, Class<?> interfaceName) { 

	Class result = (Class) object;
	if (interfaceName.isAssignableFrom (result)) {
	    return result;
	}
	else {
	    throw new ClassCastException();
	}
    }
    
    /**
     * Verify that the given object is an instance of the given interface, which 
     * is assumed to be interface {@link Attribute Attribute} or a subinterface 
     * thereof. 
     *
     * @param  object     Object to test.
     * @param  interfaceName  Interface of which the object must be an instance.
     *
     * @return  If <CODE>object</CODE> is an instance of
     *          <CODE>interfaceName</CODE>, <CODE>object</CODE> is returned 
     *          downcast to type {@link Attribute Attribute}; otherwise an 
     *          exception is thrown. 
     *
     * @exception  NullPointerException
     *     (unchecked exception) Thrown if <CODE>object</CODE> is null.
     * @exception  ClassCastException
     *     (unchecked exception) Thrown if <CODE>object</CODE> is not an 
     *     instance of <CODE>interfaceName</CODE>. 
     */
    public static Attribute
	verifyAttributeValue(Object object, Class<?> interfaceName) {

	if (object == null) {
	    throw new NullPointerException();
	}
	else if (interfaceName.isInstance (object)) {
	    return (Attribute) object;
	} else {
	    throw new ClassCastException();
	}
    }
    
    /**
     * Verify that the given attribute category object is equal to the
     * category of the given attribute value object. If so, this method 
     * returns doing nothing. If not, this method throws an exception. 
     *
     * @param  category   Attribute category to test.
     * @param  attribute  Attribute value to test.
     *
     * @exception  NullPointerException
     *     (unchecked exception) Thrown if the <CODE>category</CODE> is 
     *     null or if the <CODE>attribute</CODE> is null. 
     * @exception  IllegalArgumentException
     *     (unchecked exception) Thrown if the <CODE>category</CODE> is not 
     *     equal to the category of the <CODE>attribute</CODE>. 
     */
    public static void 
	verifyCategoryForValue(Class<?> category, Attribute attribute) {

	if (!category.equals (attribute.getCategory())) {
	    throw new IllegalArgumentException();
	}
    }
}

Generated By: JavaOnTracks Doclet 0.1.4     ©Thibaut Colar