001: /*
002: * Distributed as part of c3p0 v.0.9.1.2
003: *
004: * Copyright (C) 2005 Machinery For Change, Inc.
005: *
006: * Author: Steve Waldman <swaldman@mchange.com>
007: *
008: * This library is free software; you can redistribute it and/or modify
009: * it under the terms of the GNU Lesser General Public License version 2.1, as
010: * published by the Free Software Foundation.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
015: * GNU Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public License
018: * along with this software; see the file LICENSE. If not, write to the
019: * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
020: * Boston, MA 02111-1307, USA.
021: */
022:
023: package com.mchange.v2.sql.filter;
024:
025: import java.io.InputStream;
026: import java.io.Reader;
027: import java.lang.Object;
028: import java.lang.String;
029: import java.math.BigDecimal;
030: import java.net.URL;
031: import java.sql.Array;
032: import java.sql.Blob;
033: import java.sql.Clob;
034: import java.sql.Date;
035: import java.sql.Ref;
036: import java.sql.ResultSet;
037: import java.sql.ResultSetMetaData;
038: import java.sql.SQLException;
039: import java.sql.SQLWarning;
040: import java.sql.Statement;
041: import java.sql.Time;
042: import java.sql.Timestamp;
043: import java.util.Calendar;
044: import java.util.Map;
045:
046: public abstract class SynchronizedFilterResultSet implements ResultSet {
047: protected ResultSet inner;
048:
049: public SynchronizedFilterResultSet(ResultSet inner) {
050: this .inner = inner;
051: }
052:
053: public SynchronizedFilterResultSet() {
054: }
055:
056: public synchronized void setInner(ResultSet inner) {
057: this .inner = inner;
058: }
059:
060: public synchronized ResultSet getInner() {
061: return inner;
062: }
063:
064: public synchronized ResultSetMetaData getMetaData()
065: throws SQLException {
066: return inner.getMetaData();
067: }
068:
069: public synchronized SQLWarning getWarnings() throws SQLException {
070: return inner.getWarnings();
071: }
072:
073: public synchronized void clearWarnings() throws SQLException {
074: inner.clearWarnings();
075: }
076:
077: public synchronized boolean wasNull() throws SQLException {
078: return inner.wasNull();
079: }
080:
081: public synchronized BigDecimal getBigDecimal(int a)
082: throws SQLException {
083: return inner.getBigDecimal(a);
084: }
085:
086: public synchronized BigDecimal getBigDecimal(String a, int b)
087: throws SQLException {
088: return inner.getBigDecimal(a, b);
089: }
090:
091: public synchronized BigDecimal getBigDecimal(int a, int b)
092: throws SQLException {
093: return inner.getBigDecimal(a, b);
094: }
095:
096: public synchronized BigDecimal getBigDecimal(String a)
097: throws SQLException {
098: return inner.getBigDecimal(a);
099: }
100:
101: public synchronized Timestamp getTimestamp(int a)
102: throws SQLException {
103: return inner.getTimestamp(a);
104: }
105:
106: public synchronized Timestamp getTimestamp(String a)
107: throws SQLException {
108: return inner.getTimestamp(a);
109: }
110:
111: public synchronized Timestamp getTimestamp(int a, Calendar b)
112: throws SQLException {
113: return inner.getTimestamp(a, b);
114: }
115:
116: public synchronized Timestamp getTimestamp(String a, Calendar b)
117: throws SQLException {
118: return inner.getTimestamp(a, b);
119: }
120:
121: public synchronized InputStream getAsciiStream(String a)
122: throws SQLException {
123: return inner.getAsciiStream(a);
124: }
125:
126: public synchronized InputStream getAsciiStream(int a)
127: throws SQLException {
128: return inner.getAsciiStream(a);
129: }
130:
131: public synchronized InputStream getUnicodeStream(String a)
132: throws SQLException {
133: return inner.getUnicodeStream(a);
134: }
135:
136: public synchronized InputStream getUnicodeStream(int a)
137: throws SQLException {
138: return inner.getUnicodeStream(a);
139: }
140:
141: public synchronized InputStream getBinaryStream(int a)
142: throws SQLException {
143: return inner.getBinaryStream(a);
144: }
145:
146: public synchronized InputStream getBinaryStream(String a)
147: throws SQLException {
148: return inner.getBinaryStream(a);
149: }
150:
151: public synchronized String getCursorName() throws SQLException {
152: return inner.getCursorName();
153: }
154:
155: public synchronized Reader getCharacterStream(int a)
156: throws SQLException {
157: return inner.getCharacterStream(a);
158: }
159:
160: public synchronized Reader getCharacterStream(String a)
161: throws SQLException {
162: return inner.getCharacterStream(a);
163: }
164:
165: public synchronized boolean isBeforeFirst() throws SQLException {
166: return inner.isBeforeFirst();
167: }
168:
169: public synchronized boolean isAfterLast() throws SQLException {
170: return inner.isAfterLast();
171: }
172:
173: public synchronized boolean isFirst() throws SQLException {
174: return inner.isFirst();
175: }
176:
177: public synchronized boolean isLast() throws SQLException {
178: return inner.isLast();
179: }
180:
181: public synchronized void beforeFirst() throws SQLException {
182: inner.beforeFirst();
183: }
184:
185: public synchronized void afterLast() throws SQLException {
186: inner.afterLast();
187: }
188:
189: public synchronized boolean absolute(int a) throws SQLException {
190: return inner.absolute(a);
191: }
192:
193: public synchronized void setFetchDirection(int a)
194: throws SQLException {
195: inner.setFetchDirection(a);
196: }
197:
198: public synchronized int getFetchDirection() throws SQLException {
199: return inner.getFetchDirection();
200: }
201:
202: public synchronized void setFetchSize(int a) throws SQLException {
203: inner.setFetchSize(a);
204: }
205:
206: public synchronized int getFetchSize() throws SQLException {
207: return inner.getFetchSize();
208: }
209:
210: public synchronized int getConcurrency() throws SQLException {
211: return inner.getConcurrency();
212: }
213:
214: public synchronized boolean rowUpdated() throws SQLException {
215: return inner.rowUpdated();
216: }
217:
218: public synchronized boolean rowInserted() throws SQLException {
219: return inner.rowInserted();
220: }
221:
222: public synchronized boolean rowDeleted() throws SQLException {
223: return inner.rowDeleted();
224: }
225:
226: public synchronized void updateNull(int a) throws SQLException {
227: inner.updateNull(a);
228: }
229:
230: public synchronized void updateNull(String a) throws SQLException {
231: inner.updateNull(a);
232: }
233:
234: public synchronized void updateBoolean(int a, boolean b)
235: throws SQLException {
236: inner.updateBoolean(a, b);
237: }
238:
239: public synchronized void updateBoolean(String a, boolean b)
240: throws SQLException {
241: inner.updateBoolean(a, b);
242: }
243:
244: public synchronized void updateByte(int a, byte b)
245: throws SQLException {
246: inner.updateByte(a, b);
247: }
248:
249: public synchronized void updateByte(String a, byte b)
250: throws SQLException {
251: inner.updateByte(a, b);
252: }
253:
254: public synchronized void updateShort(int a, short b)
255: throws SQLException {
256: inner.updateShort(a, b);
257: }
258:
259: public synchronized void updateShort(String a, short b)
260: throws SQLException {
261: inner.updateShort(a, b);
262: }
263:
264: public synchronized void updateInt(String a, int b)
265: throws SQLException {
266: inner.updateInt(a, b);
267: }
268:
269: public synchronized void updateInt(int a, int b)
270: throws SQLException {
271: inner.updateInt(a, b);
272: }
273:
274: public synchronized void updateLong(int a, long b)
275: throws SQLException {
276: inner.updateLong(a, b);
277: }
278:
279: public synchronized void updateLong(String a, long b)
280: throws SQLException {
281: inner.updateLong(a, b);
282: }
283:
284: public synchronized void updateFloat(String a, float b)
285: throws SQLException {
286: inner.updateFloat(a, b);
287: }
288:
289: public synchronized void updateFloat(int a, float b)
290: throws SQLException {
291: inner.updateFloat(a, b);
292: }
293:
294: public synchronized void updateDouble(String a, double b)
295: throws SQLException {
296: inner.updateDouble(a, b);
297: }
298:
299: public synchronized void updateDouble(int a, double b)
300: throws SQLException {
301: inner.updateDouble(a, b);
302: }
303:
304: public synchronized void updateBigDecimal(int a, BigDecimal b)
305: throws SQLException {
306: inner.updateBigDecimal(a, b);
307: }
308:
309: public synchronized void updateBigDecimal(String a, BigDecimal b)
310: throws SQLException {
311: inner.updateBigDecimal(a, b);
312: }
313:
314: public synchronized void updateString(String a, String b)
315: throws SQLException {
316: inner.updateString(a, b);
317: }
318:
319: public synchronized void updateString(int a, String b)
320: throws SQLException {
321: inner.updateString(a, b);
322: }
323:
324: public synchronized void updateBytes(int a, byte[] b)
325: throws SQLException {
326: inner.updateBytes(a, b);
327: }
328:
329: public synchronized void updateBytes(String a, byte[] b)
330: throws SQLException {
331: inner.updateBytes(a, b);
332: }
333:
334: public synchronized void updateDate(String a, Date b)
335: throws SQLException {
336: inner.updateDate(a, b);
337: }
338:
339: public synchronized void updateDate(int a, Date b)
340: throws SQLException {
341: inner.updateDate(a, b);
342: }
343:
344: public synchronized void updateTimestamp(int a, Timestamp b)
345: throws SQLException {
346: inner.updateTimestamp(a, b);
347: }
348:
349: public synchronized void updateTimestamp(String a, Timestamp b)
350: throws SQLException {
351: inner.updateTimestamp(a, b);
352: }
353:
354: public synchronized void updateAsciiStream(String a, InputStream b,
355: int c) throws SQLException {
356: inner.updateAsciiStream(a, b, c);
357: }
358:
359: public synchronized void updateAsciiStream(int a, InputStream b,
360: int c) throws SQLException {
361: inner.updateAsciiStream(a, b, c);
362: }
363:
364: public synchronized void updateBinaryStream(int a, InputStream b,
365: int c) throws SQLException {
366: inner.updateBinaryStream(a, b, c);
367: }
368:
369: public synchronized void updateBinaryStream(String a,
370: InputStream b, int c) throws SQLException {
371: inner.updateBinaryStream(a, b, c);
372: }
373:
374: public synchronized void updateCharacterStream(int a, Reader b,
375: int c) throws SQLException {
376: inner.updateCharacterStream(a, b, c);
377: }
378:
379: public synchronized void updateCharacterStream(String a, Reader b,
380: int c) throws SQLException {
381: inner.updateCharacterStream(a, b, c);
382: }
383:
384: public synchronized void updateObject(String a, Object b)
385: throws SQLException {
386: inner.updateObject(a, b);
387: }
388:
389: public synchronized void updateObject(int a, Object b)
390: throws SQLException {
391: inner.updateObject(a, b);
392: }
393:
394: public synchronized void updateObject(int a, Object b, int c)
395: throws SQLException {
396: inner.updateObject(a, b, c);
397: }
398:
399: public synchronized void updateObject(String a, Object b, int c)
400: throws SQLException {
401: inner.updateObject(a, b, c);
402: }
403:
404: public synchronized void insertRow() throws SQLException {
405: inner.insertRow();
406: }
407:
408: public synchronized void updateRow() throws SQLException {
409: inner.updateRow();
410: }
411:
412: public synchronized void deleteRow() throws SQLException {
413: inner.deleteRow();
414: }
415:
416: public synchronized void refreshRow() throws SQLException {
417: inner.refreshRow();
418: }
419:
420: public synchronized void cancelRowUpdates() throws SQLException {
421: inner.cancelRowUpdates();
422: }
423:
424: public synchronized void moveToInsertRow() throws SQLException {
425: inner.moveToInsertRow();
426: }
427:
428: public synchronized void moveToCurrentRow() throws SQLException {
429: inner.moveToCurrentRow();
430: }
431:
432: public synchronized Statement getStatement() throws SQLException {
433: return inner.getStatement();
434: }
435:
436: public synchronized Blob getBlob(String a) throws SQLException {
437: return inner.getBlob(a);
438: }
439:
440: public synchronized Blob getBlob(int a) throws SQLException {
441: return inner.getBlob(a);
442: }
443:
444: public synchronized Clob getClob(String a) throws SQLException {
445: return inner.getClob(a);
446: }
447:
448: public synchronized Clob getClob(int a) throws SQLException {
449: return inner.getClob(a);
450: }
451:
452: public synchronized void updateRef(String a, Ref b)
453: throws SQLException {
454: inner.updateRef(a, b);
455: }
456:
457: public synchronized void updateRef(int a, Ref b)
458: throws SQLException {
459: inner.updateRef(a, b);
460: }
461:
462: public synchronized void updateBlob(String a, Blob b)
463: throws SQLException {
464: inner.updateBlob(a, b);
465: }
466:
467: public synchronized void updateBlob(int a, Blob b)
468: throws SQLException {
469: inner.updateBlob(a, b);
470: }
471:
472: public synchronized void updateClob(int a, Clob b)
473: throws SQLException {
474: inner.updateClob(a, b);
475: }
476:
477: public synchronized void updateClob(String a, Clob b)
478: throws SQLException {
479: inner.updateClob(a, b);
480: }
481:
482: public synchronized void updateArray(String a, Array b)
483: throws SQLException {
484: inner.updateArray(a, b);
485: }
486:
487: public synchronized void updateArray(int a, Array b)
488: throws SQLException {
489: inner.updateArray(a, b);
490: }
491:
492: public synchronized Object getObject(int a) throws SQLException {
493: return inner.getObject(a);
494: }
495:
496: public synchronized Object getObject(String a, Map b)
497: throws SQLException {
498: return inner.getObject(a, b);
499: }
500:
501: public synchronized Object getObject(String a) throws SQLException {
502: return inner.getObject(a);
503: }
504:
505: public synchronized Object getObject(int a, Map b)
506: throws SQLException {
507: return inner.getObject(a, b);
508: }
509:
510: public synchronized boolean getBoolean(int a) throws SQLException {
511: return inner.getBoolean(a);
512: }
513:
514: public synchronized boolean getBoolean(String a)
515: throws SQLException {
516: return inner.getBoolean(a);
517: }
518:
519: public synchronized byte getByte(String a) throws SQLException {
520: return inner.getByte(a);
521: }
522:
523: public synchronized byte getByte(int a) throws SQLException {
524: return inner.getByte(a);
525: }
526:
527: public synchronized short getShort(String a) throws SQLException {
528: return inner.getShort(a);
529: }
530:
531: public synchronized short getShort(int a) throws SQLException {
532: return inner.getShort(a);
533: }
534:
535: public synchronized int getInt(String a) throws SQLException {
536: return inner.getInt(a);
537: }
538:
539: public synchronized int getInt(int a) throws SQLException {
540: return inner.getInt(a);
541: }
542:
543: public synchronized long getLong(int a) throws SQLException {
544: return inner.getLong(a);
545: }
546:
547: public synchronized long getLong(String a) throws SQLException {
548: return inner.getLong(a);
549: }
550:
551: public synchronized float getFloat(String a) throws SQLException {
552: return inner.getFloat(a);
553: }
554:
555: public synchronized float getFloat(int a) throws SQLException {
556: return inner.getFloat(a);
557: }
558:
559: public synchronized double getDouble(int a) throws SQLException {
560: return inner.getDouble(a);
561: }
562:
563: public synchronized double getDouble(String a) throws SQLException {
564: return inner.getDouble(a);
565: }
566:
567: public synchronized byte[] getBytes(String a) throws SQLException {
568: return inner.getBytes(a);
569: }
570:
571: public synchronized byte[] getBytes(int a) throws SQLException {
572: return inner.getBytes(a);
573: }
574:
575: public synchronized boolean next() throws SQLException {
576: return inner.next();
577: }
578:
579: public synchronized URL getURL(int a) throws SQLException {
580: return inner.getURL(a);
581: }
582:
583: public synchronized URL getURL(String a) throws SQLException {
584: return inner.getURL(a);
585: }
586:
587: public synchronized int getType() throws SQLException {
588: return inner.getType();
589: }
590:
591: public synchronized boolean previous() throws SQLException {
592: return inner.previous();
593: }
594:
595: public synchronized void close() throws SQLException {
596: inner.close();
597: }
598:
599: public synchronized String getString(String a) throws SQLException {
600: return inner.getString(a);
601: }
602:
603: public synchronized String getString(int a) throws SQLException {
604: return inner.getString(a);
605: }
606:
607: public synchronized Ref getRef(String a) throws SQLException {
608: return inner.getRef(a);
609: }
610:
611: public synchronized Ref getRef(int a) throws SQLException {
612: return inner.getRef(a);
613: }
614:
615: public synchronized Time getTime(int a, Calendar b)
616: throws SQLException {
617: return inner.getTime(a, b);
618: }
619:
620: public synchronized Time getTime(String a) throws SQLException {
621: return inner.getTime(a);
622: }
623:
624: public synchronized Time getTime(int a) throws SQLException {
625: return inner.getTime(a);
626: }
627:
628: public synchronized Time getTime(String a, Calendar b)
629: throws SQLException {
630: return inner.getTime(a, b);
631: }
632:
633: public synchronized Date getDate(String a) throws SQLException {
634: return inner.getDate(a);
635: }
636:
637: public synchronized Date getDate(int a) throws SQLException {
638: return inner.getDate(a);
639: }
640:
641: public synchronized Date getDate(int a, Calendar b)
642: throws SQLException {
643: return inner.getDate(a, b);
644: }
645:
646: public synchronized Date getDate(String a, Calendar b)
647: throws SQLException {
648: return inner.getDate(a, b);
649: }
650:
651: public synchronized boolean first() throws SQLException {
652: return inner.first();
653: }
654:
655: public synchronized boolean last() throws SQLException {
656: return inner.last();
657: }
658:
659: public synchronized Array getArray(String a) throws SQLException {
660: return inner.getArray(a);
661: }
662:
663: public synchronized Array getArray(int a) throws SQLException {
664: return inner.getArray(a);
665: }
666:
667: public synchronized boolean relative(int a) throws SQLException {
668: return inner.relative(a);
669: }
670:
671: public synchronized void updateTime(String a, Time b)
672: throws SQLException {
673: inner.updateTime(a, b);
674: }
675:
676: public synchronized void updateTime(int a, Time b)
677: throws SQLException {
678: inner.updateTime(a, b);
679: }
680:
681: public synchronized int findColumn(String a) throws SQLException {
682: return inner.findColumn(a);
683: }
684:
685: public synchronized int getRow() throws SQLException {
686: return inner.getRow();
687: }
688: }
|