]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.scenegraph/src/gnu/trove/SerializationProcedure.java
Allow specification of Locale to FormattingUtils.significantDigitFormat
[simantics/platform.git] / bundles / org.simantics.scenegraph / src / gnu / trove / SerializationProcedure.java
1 ///////////////////////////////////////////////////////////////////////////////
2 // Copyright (c) 2002, Eric D. Friedman All Rights Reserved.
3 //
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either
7 // version 2.1 of the License, or (at your option) any later version.
8 //
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU Lesser General Public
15 // License along with this program; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17 ///////////////////////////////////////////////////////////////////////////////
18
19 package gnu.trove;
20
21 import java.io.IOException;
22 import java.io.ObjectOutput;
23
24
25 /**
26  * Implementation of the variously typed procedure interfaces that supports
27  * writing the arguments to the procedure out on an ObjectOutputStream.
28  * In the case of two-argument procedures, the arguments are written out
29  * in the order received.
30  *
31  * <p>
32  * Any IOException is trapped here so that it can be rethrown in a writeObject
33  * method.
34  * </p>
35  *
36  * Created: Sun Jul  7 00:14:18 2002
37  *
38  * @author Eric D. Friedman
39  * @version $Id: SerializationProcedure.java,v 1.5 2006/11/10 23:27:54 robeden Exp $
40  */
41
42 @SuppressWarnings("rawtypes")
43 class SerializationProcedure implements
44 //    TDoubleDoubleProcedure,
45 //    TDoubleFloatProcedure,
46 //    TDoubleIntProcedure,
47 //    TDoubleLongProcedure,
48 //    TDoubleShortProcedure,
49 //    TDoubleByteProcedure,
50 //    TDoubleObjectProcedure,
51 //    TDoubleProcedure,
52 //    TFloatDoubleProcedure,
53 //    TFloatFloatProcedure,
54 //    TFloatIntProcedure,
55 //    TFloatLongProcedure,
56 //    TFloatShortProcedure,
57 //    TFloatByteProcedure,
58 //    TFloatObjectProcedure,
59 TFloatProcedure,
60 //    TIntDoubleProcedure,
61 //    TIntFloatProcedure,
62 //    TIntIntProcedure,
63 //    TIntLongProcedure,
64 //    TIntShortProcedure,
65 //    TIntByteProcedure,
66 TIntObjectProcedure,
67 TIntProcedure
68 //    TLongDoubleProcedure,
69 //    TLongFloatProcedure,
70 //    TLongIntProcedure,
71 //    TLongLongProcedure,
72 //    TLongShortProcedure,
73 //    TLongByteProcedure,
74 //    TLongObjectProcedure,
75 //    TLongProcedure,
76 //    TShortDoubleProcedure,
77 //    TShortFloatProcedure,
78 //    TShortIntProcedure,
79 //    TShortLongProcedure,
80 //    TShortShortProcedure,
81 //    TShortByteProcedure,
82 //    TShortObjectProcedure,
83 //    TShortProcedure,
84 //    TByteDoubleProcedure,
85 //    TByteFloatProcedure,
86 //    TByteIntProcedure,
87 //    TByteLongProcedure,
88 //    TByteShortProcedure,
89 //    TByteByteProcedure,
90 //    TByteObjectProcedure,
91 //    TByteProcedure,
92 //    TObjectDoubleProcedure,
93 //    TObjectFloatProcedure,
94 //    TObjectIntProcedure,
95 //    TObjectLongProcedure,
96 //    TObjectShortProcedure,
97 //    TObjectByteProcedure,
98 //    TObjectObjectProcedure,
99 //    TObjectProcedure
100 {
101
102     private final ObjectOutput stream;
103     IOException exception;
104
105     SerializationProcedure ( ObjectOutput stream) {
106         this.stream = stream;
107     }
108
109 //    public boolean execute(byte val) {
110 //        try {
111 //            stream.writeByte(val);
112 //        } catch (IOException e) {
113 //            this.exception = e;
114 //            return false;
115 //        }
116 //        return true;
117 //    }
118 //
119 //    public boolean execute(short val) {
120 //        try {
121 //            stream.writeShort(val);
122 //        } catch (IOException e) {
123 //            this.exception = e;
124 //            return false;
125 //        }
126 //        return true;
127 //    }
128
129     @Override
130     public boolean execute(int val) {
131         try {
132             stream.writeInt(val);
133         } catch (IOException e) {
134             this.exception = e;
135             return false;
136         }
137         return true;
138     }
139
140 //    public boolean execute(double val) {
141 //        try {
142 //            stream.writeDouble(val);
143 //        } catch (IOException e) {
144 //            this.exception = e;
145 //            return false;
146 //        }
147 //        return true;
148 //    }
149 //
150 //    public boolean execute(long val) {
151 //        try {
152 //            stream.writeLong(val);
153 //        } catch (IOException e) {
154 //            this.exception = e;
155 //            return false;
156 //        }
157 //        return true;
158 //    }
159
160     @Override
161     public boolean execute(float val) {
162         try {
163             stream.writeFloat(val);
164         } catch (IOException e) {
165             this.exception = e;
166             return false;
167         }
168         return true;
169     }
170
171 //    public boolean execute(Object val) {
172 //        try {
173 //            stream.writeObject(val);
174 //        } catch (IOException e) {
175 //            this.exception = e;
176 //            return false;
177 //        }
178 //        return true;
179 //    }
180 //
181 //    public boolean execute(Object key, Object val) {
182 //        try {
183 //            stream.writeObject(key);
184 //            stream.writeObject(val);
185 //        } catch (IOException e) {
186 //            this.exception = e;
187 //            return false;
188 //        }
189 //        return true;
190 //    }
191 //
192 //    public boolean execute(Object key, byte val) {
193 //        try {
194 //            stream.writeObject(key);
195 //            stream.writeByte(val);
196 //        } catch (IOException e) {
197 //            this.exception = e;
198 //            return false;
199 //        }
200 //        return true;
201 //    }
202 //
203 //    public boolean execute(Object key, short val) {
204 //        try {
205 //            stream.writeObject(key);
206 //            stream.writeShort(val);
207 //        } catch (IOException e) {
208 //            this.exception = e;
209 //            return false;
210 //        }
211 //        return true;
212 //    }
213 //
214 //    public boolean execute(Object key, int val) {
215 //        try {
216 //            stream.writeObject(key);
217 //            stream.writeInt(val);
218 //        } catch (IOException e) {
219 //            this.exception = e;
220 //            return false;
221 //        }
222 //        return true;
223 //    }
224 //
225 //    public boolean execute(Object key, long val) {
226 //        try {
227 //            stream.writeObject(key);
228 //            stream.writeLong(val);
229 //        } catch (IOException e) {
230 //            this.exception = e;
231 //            return false;
232 //        }
233 //        return true;
234 //    }
235 //
236 //    public boolean execute(Object key, double val) {
237 //        try {
238 //            stream.writeObject(key);
239 //            stream.writeDouble(val);
240 //        } catch (IOException e) {
241 //            this.exception = e;
242 //            return false;
243 //        }
244 //        return true;
245 //    }
246 //
247 //    public boolean execute(Object key, float val) {
248 //        try {
249 //            stream.writeObject(key);
250 //            stream.writeFloat(val);
251 //        } catch (IOException e) {
252 //            this.exception = e;
253 //            return false;
254 //        }
255 //        return true;
256 //    }
257 //
258 //    public boolean execute(int key, byte val) {
259 //        try {
260 //            stream.writeInt(key);
261 //            stream.writeByte(val);
262 //        } catch (IOException e) {
263 //            this.exception = e;
264 //            return false;
265 //        }
266 //        return true;
267 //    }
268 //
269 //    public boolean execute(int key, short val) {
270 //        try {
271 //            stream.writeInt(key);
272 //            stream.writeShort(val);
273 //        } catch (IOException e) {
274 //            this.exception = e;
275 //            return false;
276 //        }
277 //        return true;
278 //    }
279
280     @Override
281     public boolean execute(int key, Object val) {
282         try {
283             stream.writeInt(key);
284             stream.writeObject(val);
285         } catch (IOException e) {
286             this.exception = e;
287             return false;
288         }
289         return true;
290     }
291
292 //    public boolean execute(int key, int val) {
293 //        try {
294 //            stream.writeInt(key);
295 //            stream.writeInt(val);
296 //        } catch (IOException e) {
297 //            this.exception = e;
298 //            return false;
299 //        }
300 //        return true;
301 //    }
302 //
303 //    public boolean execute(int key, long val) {
304 //        try {
305 //            stream.writeInt(key);
306 //            stream.writeLong(val);
307 //        } catch (IOException e) {
308 //            this.exception = e;
309 //            return false;
310 //        }
311 //        return true;
312 //    }
313 //
314 //    public boolean execute(int key, double val) {
315 //        try {
316 //            stream.writeInt(key);
317 //            stream.writeDouble(val);
318 //        } catch (IOException e) {
319 //            this.exception = e;
320 //            return false;
321 //        }
322 //        return true;
323 //    }
324 //
325 //    public boolean execute(int key, float val) {
326 //        try {
327 //            stream.writeInt(key);
328 //            stream.writeFloat(val);
329 //        } catch (IOException e) {
330 //            this.exception = e;
331 //            return false;
332 //        }
333 //        return true;
334 //    }
335
336 //    public boolean execute(long key, Object val) {
337 //        try {
338 //            stream.writeLong(key);
339 //            stream.writeObject(val);
340 //        } catch (IOException e) {
341 //            this.exception = e;
342 //            return false;
343 //        }
344 //        return true;
345 //    }
346 //
347 //    public boolean execute(long key, byte val) {
348 //        try {
349 //            stream.writeLong(key);
350 //            stream.writeByte(val);
351 //        } catch (IOException e) {
352 //            this.exception = e;
353 //            return false;
354 //        }
355 //        return true;
356 //    }
357 //
358 //    public boolean execute(long key, short val) {
359 //        try {
360 //            stream.writeLong(key);
361 //            stream.writeShort(val);
362 //        } catch (IOException e) {
363 //            this.exception = e;
364 //            return false;
365 //        }
366 //        return true;
367 //    }
368 //
369 //    public boolean execute(long key, int val) {
370 //        try {
371 //            stream.writeLong(key);
372 //            stream.writeInt(val);
373 //        } catch (IOException e) {
374 //            this.exception = e;
375 //            return false;
376 //        }
377 //        return true;
378 //    }
379 //
380 //    public boolean execute(long key, long val) {
381 //        try {
382 //            stream.writeLong(key);
383 //            stream.writeLong(val);
384 //        } catch (IOException e) {
385 //            this.exception = e;
386 //            return false;
387 //        }
388 //        return true;
389 //    }
390 //
391 //    public boolean execute(long key, double val) {
392 //        try {
393 //            stream.writeLong(key);
394 //            stream.writeDouble(val);
395 //        } catch (IOException e) {
396 //            this.exception = e;
397 //            return false;
398 //        }
399 //        return true;
400 //    }
401 //
402 //    public boolean execute(long key, float val) {
403 //        try {
404 //            stream.writeLong(key);
405 //            stream.writeFloat(val);
406 //        } catch (IOException e) {
407 //            this.exception = e;
408 //            return false;
409 //        }
410 //        return true;
411 //    }
412 //
413 //    public boolean execute(double key, Object val) {
414 //        try {
415 //            stream.writeDouble(key);
416 //            stream.writeObject(val);
417 //        } catch (IOException e) {
418 //            this.exception = e;
419 //            return false;
420 //        }
421 //        return true;
422 //    }
423 //
424 //    public boolean execute(double key, byte val) {
425 //        try {
426 //            stream.writeDouble(key);
427 //            stream.writeByte(val);
428 //        } catch (IOException e) {
429 //            this.exception = e;
430 //            return false;
431 //        }
432 //        return true;
433 //    }
434 //
435 //    public boolean execute(double key, short val) {
436 //        try {
437 //            stream.writeDouble(key);
438 //            stream.writeShort(val);
439 //        } catch (IOException e) {
440 //            this.exception = e;
441 //            return false;
442 //        }
443 //        return true;
444 //    }
445 //
446 //    public boolean execute(double key, int val) {
447 //        try {
448 //            stream.writeDouble(key);
449 //            stream.writeInt(val);
450 //        } catch (IOException e) {
451 //            this.exception = e;
452 //            return false;
453 //        }
454 //        return true;
455 //    }
456 //
457 //    public boolean execute(double key, long val) {
458 //        try {
459 //            stream.writeDouble(key);
460 //            stream.writeLong(val);
461 //        } catch (IOException e) {
462 //            this.exception = e;
463 //            return false;
464 //        }
465 //        return true;
466 //    }
467 //
468 //    public boolean execute(double key, double val) {
469 //        try {
470 //            stream.writeDouble(key);
471 //            stream.writeDouble(val);
472 //        } catch (IOException e) {
473 //            this.exception = e;
474 //            return false;
475 //        }
476 //        return true;
477 //    }
478 //
479 //    public boolean execute(double key, float val) {
480 //        try {
481 //            stream.writeDouble(key);
482 //            stream.writeFloat(val);
483 //        } catch (IOException e) {
484 //            this.exception = e;
485 //            return false;
486 //        }
487 //        return true;
488 //    }
489 //
490 //    public boolean execute(float key, Object val) {
491 //        try {
492 //            stream.writeFloat(key);
493 //            stream.writeObject(val);
494 //        } catch (IOException e) {
495 //            this.exception = e;
496 //            return false;
497 //        }
498 //        return true;
499 //    }
500 //
501 //    public boolean execute(float key, byte val) {
502 //        try {
503 //            stream.writeFloat(key);
504 //            stream.writeByte(val);
505 //        } catch (IOException e) {
506 //            this.exception = e;
507 //            return false;
508 //        }
509 //        return true;
510 //    }
511 //
512 //    public boolean execute(float key, short val) {
513 //        try {
514 //            stream.writeFloat(key);
515 //            stream.writeShort(val);
516 //        } catch (IOException e) {
517 //            this.exception = e;
518 //            return false;
519 //        }
520 //        return true;
521 //    }
522 //
523 //    public boolean execute(float key, int val) {
524 //        try {
525 //            stream.writeFloat(key);
526 //            stream.writeInt(val);
527 //        } catch (IOException e) {
528 //            this.exception = e;
529 //            return false;
530 //        }
531 //        return true;
532 //    }
533 //
534 //    public boolean execute(float key, long val) {
535 //        try {
536 //            stream.writeFloat(key);
537 //            stream.writeLong(val);
538 //        } catch (IOException e) {
539 //            this.exception = e;
540 //            return false;
541 //        }
542 //        return true;
543 //    }
544 //
545 //    public boolean execute(float key, double val) {
546 //        try {
547 //            stream.writeFloat(key);
548 //            stream.writeDouble(val);
549 //        } catch (IOException e) {
550 //            this.exception = e;
551 //            return false;
552 //        }
553 //        return true;
554 //    }
555 //
556 //    public boolean execute(float key, float val) {
557 //        try {
558 //            stream.writeFloat(key);
559 //            stream.writeFloat(val);
560 //        } catch (IOException e) {
561 //            this.exception = e;
562 //            return false;
563 //        }
564 //        return true;
565 //    }
566 //
567 //    public boolean execute(byte key, Object val) {
568 //        try {
569 //            stream.writeByte(key);
570 //            stream.writeObject(val);
571 //        } catch (IOException e) {
572 //            this.exception = e;
573 //            return false;
574 //        }
575 //        return true;
576 //    }
577 //
578 //    public boolean execute(byte key, byte val) {
579 //        try {
580 //            stream.writeByte(key);
581 //            stream.writeByte(val);
582 //        } catch (IOException e) {
583 //            this.exception = e;
584 //            return false;
585 //        }
586 //        return true;
587 //    }
588 //
589 //    public boolean execute(byte key, short val) {
590 //        try {
591 //            stream.writeByte(key);
592 //            stream.writeShort(val);
593 //        } catch (IOException e) {
594 //            this.exception = e;
595 //            return false;
596 //        }
597 //        return true;
598 //    }
599 //
600 //    public boolean execute(byte key, int val) {
601 //        try {
602 //            stream.writeByte(key);
603 //            stream.writeInt(val);
604 //        } catch (IOException e) {
605 //            this.exception = e;
606 //            return false;
607 //        }
608 //        return true;
609 //    }
610 //
611 //    public boolean execute(byte key, long val) {
612 //        try {
613 //            stream.writeByte(key);
614 //            stream.writeLong(val);
615 //        } catch (IOException e) {
616 //            this.exception = e;
617 //            return false;
618 //        }
619 //        return true;
620 //    }
621 //
622 //    public boolean execute(byte key, double val) {
623 //        try {
624 //            stream.writeByte(key);
625 //            stream.writeDouble(val);
626 //        } catch (IOException e) {
627 //            this.exception = e;
628 //            return false;
629 //        }
630 //        return true;
631 //    }
632 //
633 //    public boolean execute(byte key, float val) {
634 //        try {
635 //            stream.writeByte(key);
636 //            stream.writeFloat(val);
637 //        } catch (IOException e) {
638 //            this.exception = e;
639 //            return false;
640 //        }
641 //        return true;
642 //    }
643 //
644 //    public boolean execute(short key, Object val) {
645 //        try {
646 //            stream.writeShort(key);
647 //            stream.writeObject(val);
648 //        } catch (IOException e) {
649 //            this.exception = e;
650 //            return false;
651 //        }
652 //        return true;
653 //    }
654 //
655 //    public boolean execute(short key, byte val) {
656 //        try {
657 //            stream.writeShort(key);
658 //            stream.writeByte(val);
659 //        } catch (IOException e) {
660 //            this.exception = e;
661 //            return false;
662 //        }
663 //        return true;
664 //    }
665 //
666 //    public boolean execute(short key, short val) {
667 //        try {
668 //            stream.writeShort(key);
669 //            stream.writeShort(val);
670 //        } catch (IOException e) {
671 //            this.exception = e;
672 //            return false;
673 //        }
674 //        return true;
675 //    }
676 //
677 //    public boolean execute(short key, int val) {
678 //        try {
679 //            stream.writeShort(key);
680 //            stream.writeInt(val);
681 //        } catch (IOException e) {
682 //            this.exception = e;
683 //            return false;
684 //        }
685 //        return true;
686 //    }
687 //
688 //    public boolean execute(short key, long val) {
689 //        try {
690 //            stream.writeShort(key);
691 //            stream.writeLong(val);
692 //        } catch (IOException e) {
693 //            this.exception = e;
694 //            return false;
695 //        }
696 //        return true;
697 //    }
698 //
699 //    public boolean execute(short key, double val) {
700 //        try {
701 //            stream.writeShort(key);
702 //            stream.writeDouble(val);
703 //        } catch (IOException e) {
704 //            this.exception = e;
705 //            return false;
706 //        }
707 //        return true;
708 //    }
709 //
710 //    public boolean execute(short key, float val) {
711 //        try {
712 //            stream.writeShort(key);
713 //            stream.writeFloat(val);
714 //        } catch (IOException e) {
715 //            this.exception = e;
716 //            return false;
717 //        }
718 //        return true;
719 //    }
720 }// SerializationProcedure