]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.db.common/src/org/simantics/db/common/processor/ProcessorBase.java
Export also dynamic issues to issue CSV export file
[simantics/platform.git] / bundles / org.simantics.db.common / src / org / simantics / db / common / processor / ProcessorBase.java
1 /*******************************************************************************
2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
3  * in Industry THTH ry.
4  * All rights reserved. This program and the accompanying materials
5  * are made available under the terms of the Eclipse Public License v1.0
6  * which accompanies this distribution, and is available at
7  * http://www.eclipse.org/legal/epl-v10.html
8  *
9  * Contributors:
10  *     VTT Technical Research Centre of Finland - initial API and implementation
11  *******************************************************************************/
12 package org.simantics.db.common.processor;
13
14 import java.util.Collection;
15
16 import org.simantics.db.RequestProcessor;
17 import org.simantics.db.Resource;
18 import org.simantics.db.Session;
19 import org.simantics.db.exception.DatabaseException;
20 import org.simantics.db.procedure.AsyncListener;
21 import org.simantics.db.procedure.AsyncMultiListener;
22 import org.simantics.db.procedure.AsyncMultiProcedure;
23 import org.simantics.db.procedure.AsyncProcedure;
24 import org.simantics.db.procedure.Listener;
25 import org.simantics.db.procedure.MultiListener;
26 import org.simantics.db.procedure.MultiProcedure;
27 import org.simantics.db.procedure.Procedure;
28 import org.simantics.db.procedure.SyncListener;
29 import org.simantics.db.procedure.SyncMultiListener;
30 import org.simantics.db.procedure.SyncMultiProcedure;
31 import org.simantics.db.procedure.SyncProcedure;
32 import org.simantics.db.request.AsyncMultiRead;
33 import org.simantics.db.request.AsyncRead;
34 import org.simantics.db.request.DelayedWrite;
35 import org.simantics.db.request.DelayedWriteResult;
36 import org.simantics.db.request.ExternalRead;
37 import org.simantics.db.request.MultiRead;
38 import org.simantics.db.request.Read;
39 import org.simantics.db.request.ReadInterface;
40 import org.simantics.db.request.Write;
41 import org.simantics.db.request.WriteInterface;
42 import org.simantics.db.request.WriteOnly;
43 import org.simantics.db.request.WriteOnlyResult;
44 import org.simantics.db.request.WriteResult;
45 import org.simantics.utils.datastructures.Callback;
46
47 public class ProcessorBase implements RequestProcessor {
48
49     @Override
50     public <T> void asyncRequest(AsyncMultiRead<T> request, AsyncMultiProcedure<T> procedure) {
51         throw new UnsupportedOperationException();
52     }
53
54     @Override
55     public <T> void asyncRequest(AsyncRead<T> request, AsyncProcedure<T> procedure) {
56         throw new UnsupportedOperationException();
57     }
58
59     @Override
60     public void asyncRequest(Write request, Callback<DatabaseException> callback) {
61         throw new UnsupportedOperationException();
62     }
63
64     @Override
65     public void asyncRequest(DelayedWrite request, Callback<DatabaseException> callback) {
66         throw new UnsupportedOperationException();
67     }
68
69     @Override
70     public void asyncRequest(WriteOnly request, Callback<DatabaseException> callback) {
71         throw new UnsupportedOperationException();
72     }
73
74     @Override
75     public <T> Collection<T> syncRequest(AsyncMultiRead<T> request, final AsyncMultiProcedure<T> procedure) {
76         throw new UnsupportedOperationException();
77     }
78
79     @Override
80     public <T> T syncRequest(AsyncRead<T> request, final AsyncProcedure<T> procedure) {
81         throw new UnsupportedOperationException();
82     }
83
84
85     @Override
86     public void syncRequest(Write request) {
87         throw new UnsupportedOperationException();
88     }
89
90     @Override
91     public void syncRequest(WriteOnly request) {
92         throw new UnsupportedOperationException();
93     }
94
95     @Override
96     public Session getSession() {
97         throw new UnsupportedOperationException();
98     }
99
100     @Override
101     public <T> void asyncRequest(AsyncRead<T> request) {
102         throw new UnsupportedOperationException();
103     }
104
105     @Override
106     public <T> void asyncRequest(AsyncRead<T> request,
107             Procedure<T> procedure) {
108         throw new UnsupportedOperationException();
109     }
110
111     @Override
112     public <T> void asyncRequest(AsyncMultiRead<T> request) {
113         throw new UnsupportedOperationException();
114     }
115
116     @Override
117     public <T> void asyncRequest(AsyncMultiRead<T> request,
118             MultiProcedure<T> procedure) {
119         throw new UnsupportedOperationException();
120     }
121
122     @Override
123     public <T> T syncRequest(AsyncRead<T> request) {
124         throw new UnsupportedOperationException();
125     }
126
127     @Override
128     public <T> T syncRequest(AsyncRead<T> request,
129             Procedure<T> procedure) {
130         throw new UnsupportedOperationException();
131     }
132
133     @Override
134     public <T> Collection<T> syncRequest(AsyncMultiRead<T> request) {
135         throw new UnsupportedOperationException();
136     }
137
138     @Override
139     public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
140             MultiProcedure<T> procedure) {
141         throw new UnsupportedOperationException();
142     }
143
144     @Override
145     public <T> T syncRequest(Read<T> request) {
146         throw new UnsupportedOperationException();
147     }
148
149     @Override
150     public <T> T syncRequest(Read<T> request,
151             final AsyncProcedure<T> procedure) {
152         throw new UnsupportedOperationException();
153     }
154
155     @Override
156     public <T> void asyncRequest(Read<T> request) {
157         throw new UnsupportedOperationException();
158     }
159
160     @Override
161     public <T> void asyncRequest(Read<T> request,
162             AsyncProcedure<T> procedure) {
163         throw new UnsupportedOperationException();
164     }
165
166     @Override
167     public <T> T syncRequest(Read<T> request, Procedure<T> procedure) {
168         throw new UnsupportedOperationException();
169     }
170
171     @Override
172     public <T> Collection<T> syncRequest(final MultiRead<T> request) throws DatabaseException {
173         throw new UnsupportedOperationException();
174     }
175
176     @Override
177     public <T> Collection<T> syncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure)  {
178         throw new UnsupportedOperationException();
179     }
180
181     @Override
182     public <T> Collection<T> syncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
183         throw new UnsupportedOperationException();
184     }
185
186     @Override
187     public <T> void asyncRequest(Read<T> request, Procedure<T> procedure) {
188         throw new UnsupportedOperationException();
189     }
190
191     @Override
192     public <T> void asyncRequest(MultiRead<T> request) {
193         throw new UnsupportedOperationException();
194     }
195
196     @Override
197     public <T> void asyncRequest(MultiRead<T> request, AsyncMultiProcedure<T> procedure) {
198         throw new UnsupportedOperationException();
199     }
200
201     @Override
202     public <T> void asyncRequest(MultiRead<T> request, MultiProcedure<T> procedure) {
203         throw new UnsupportedOperationException();
204     }
205
206     @Override
207     public void asyncRequest(Write r) {
208         throw new UnsupportedOperationException();
209     }
210
211     @Override
212     public void asyncRequest(WriteOnly r) {
213         throw new UnsupportedOperationException();
214     }
215
216     @Override
217     public <T> T getService(Class<T> api) {
218         throw new UnsupportedOperationException();
219     }
220
221     @Override
222     public <T> T peekService(Class<T> api) {
223         throw new UnsupportedOperationException();
224     }
225
226     @Override
227     public boolean hasService(Class<?> api) {
228         throw new UnsupportedOperationException();
229     }
230
231     @Override
232     public <T> void registerService(Class<T> api, T service) {
233         throw new UnsupportedOperationException();
234     }
235
236 //    @Override
237 //    public <T> T syncRequest(Read<T> arg0, AsyncListener<T> arg1) {
238 //        throw new UnsupportedOperationException();
239 //    }
240
241     @Override
242     public <T> T syncRequest(Read<T> arg0, SyncListener<T> arg1) {
243         throw new UnsupportedOperationException();
244     }
245
246     @Override
247     public <T> T syncRequest(Read<T> arg0, Listener<T> arg1) {
248         throw new UnsupportedOperationException();
249     }
250
251     @Override
252     public <T> T syncRequest(Read<T> arg0, SyncProcedure<T> arg1) {
253         throw new UnsupportedOperationException();
254     }
255
256     @Override
257     public <T> T syncRequest(AsyncRead<T> arg0, AsyncListener<T> arg1) {
258         throw new UnsupportedOperationException();
259     }
260
261     @Override
262     public <T> T syncRequest(AsyncRead<T> arg0, SyncListener<T> arg1) {
263         throw new UnsupportedOperationException();
264     }
265
266     @Override
267     public <T> T syncRequest(AsyncRead<T> arg0, Listener<T> arg1) {
268         throw new UnsupportedOperationException();
269     }
270
271     @Override
272     public <T> T syncRequest(AsyncRead<T> arg0, SyncProcedure<T> arg1) {
273         throw new UnsupportedOperationException();
274     }
275
276     @Override
277     public <T> void asyncRequest(Read<T> arg0, AsyncListener<T> arg1) {
278         throw new UnsupportedOperationException();
279     }
280
281     @Override
282     public <T> void asyncRequest(Read<T> arg0, SyncListener<T> arg1) {
283         throw new UnsupportedOperationException();
284     }
285
286     @Override
287     public <T> void asyncRequest(Read<T> arg0, Listener<T> arg1) {
288         throw new UnsupportedOperationException();
289     }
290
291     @Override
292     public <T> void asyncRequest(Read<T> arg0, SyncProcedure<T> arg1) {
293         throw new UnsupportedOperationException();
294     }
295
296     @Override
297     public <T> void asyncRequest(AsyncRead<T> arg0, AsyncListener<T> arg1) {
298         throw new UnsupportedOperationException();
299     }
300
301     @Override
302     public <T> void asyncRequest(AsyncRead<T> arg0, SyncListener<T> arg1) {
303         throw new UnsupportedOperationException();
304     }
305
306     @Override
307     public <T> void asyncRequest(AsyncRead<T> arg0, Listener<T> arg1) {
308         throw new UnsupportedOperationException();
309     }
310
311     @Override
312     public <T> void asyncRequest(AsyncRead<T> arg0, SyncProcedure<T> arg1) {
313         throw new UnsupportedOperationException();
314     }
315
316     @Override
317     public <T> Collection<T> syncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
318         throw new UnsupportedOperationException();
319     }
320
321     @Override
322     public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
323         throw new UnsupportedOperationException();
324     }
325
326     @Override
327     public <T> Collection<T> syncRequest(MultiRead<T> arg0, MultiListener<T> arg1) {
328         throw new UnsupportedOperationException();
329     }
330
331     @Override
332     public <T> Collection<T> syncRequest(MultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
333         throw new UnsupportedOperationException();
334     }
335
336     @Override
337     public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0,
338             AsyncMultiListener<T> arg1) {
339         throw new UnsupportedOperationException();
340     }
341
342     @Override
343     public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0, SyncMultiListener<T> arg1) {
344         throw new UnsupportedOperationException();
345     }
346
347     @Override
348     public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0,
349             MultiListener<T> arg1) {
350         throw new UnsupportedOperationException();
351     }
352
353     @Override
354     public <T> Collection<T> syncRequest(AsyncMultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
355         throw new UnsupportedOperationException();
356     }
357
358     @Override
359     public <T> void asyncRequest(MultiRead<T> arg0, AsyncMultiListener<T> arg1) {
360         throw new UnsupportedOperationException();
361     }
362
363     @Override
364     public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiListener<T> arg1) {
365         throw new UnsupportedOperationException();
366     }
367
368     @Override
369     public <T> void asyncRequest(MultiRead<T> arg0, MultiListener<T> arg1) {
370         throw new UnsupportedOperationException();
371     }
372
373     @Override
374     public <T> void asyncRequest(MultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
375         throw new UnsupportedOperationException();
376     }
377
378     @Override
379     public <T> void asyncRequest(AsyncMultiRead<T> arg0,
380             AsyncMultiListener<T> arg1) {
381         throw new UnsupportedOperationException();
382     }
383
384     @Override
385     public <T> void asyncRequest(AsyncMultiRead<T> arg0, SyncMultiListener<T> arg1) {
386         throw new UnsupportedOperationException();
387     }
388
389     @Override
390     public <T> void asyncRequest(AsyncMultiRead<T> arg0,
391             MultiListener<T> arg1) {
392         throw new UnsupportedOperationException();
393     }
394
395     @Override
396     public <T> void asyncRequest(AsyncMultiRead<T> arg0, SyncMultiProcedure<T> arg1) {
397         throw new UnsupportedOperationException();
398     }
399
400     @Override
401     public <T> void asyncRequest(ExternalRead<T> request, Procedure<T> procedure) {
402         throw new UnsupportedOperationException();
403     }
404
405     @Override
406     public <T> T syncRequest(ExternalRead<T> request) {
407         throw new UnsupportedOperationException();
408     }
409
410     @Override
411     public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) {
412         throw new UnsupportedOperationException();
413     }
414
415     @Override
416     public <T> T syncRequest(ExternalRead<T> request, Procedure<T> procedure) {
417         throw new UnsupportedOperationException();
418     }
419
420     @Override
421     public <T> void asyncRequest(ExternalRead<T> request) {
422         throw new UnsupportedOperationException();
423     }
424
425     @Override
426     public <T> void asyncRequest(ExternalRead<T> request, Listener<T> procedure) {
427         throw new UnsupportedOperationException();
428     }
429
430     @Override
431     public void syncRequest(DelayedWrite request) throws DatabaseException {
432         throw new UnsupportedOperationException();
433     }
434
435     @Override
436     public void asyncRequest(DelayedWrite request) {
437         throw new UnsupportedOperationException();
438     }
439
440         @Override
441         public <T> T syncRequest(WriteResult<T> request) throws DatabaseException {
442                 throw new UnsupportedOperationException();
443         }
444
445         @Override
446         public <T> T syncRequest(DelayedWriteResult<T> request)
447                         throws DatabaseException {
448                 throw new UnsupportedOperationException();
449         }
450
451         @Override
452         public <T> T syncRequest(WriteOnlyResult<T> r) throws DatabaseException {
453                 throw new UnsupportedOperationException();
454         }
455
456         @Override
457         public <T> void asyncRequest(WriteResult<T> r, Procedure<T> procedure) {
458                 throw new UnsupportedOperationException();
459         }
460
461         @Override
462         public <T> void asyncRequest(DelayedWriteResult<T> r, Procedure<T> procedure) {
463                 throw new UnsupportedOperationException();
464         }
465
466         @Override
467         public <T> void asyncRequest(WriteOnlyResult<T> r, Procedure<T> procedure) {
468                 throw new UnsupportedOperationException();
469         }
470         
471         @Override
472         public Resource getRootLibrary() {
473                 throw new UnsupportedOperationException();
474         }
475
476         @Override
477         public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
478                 throw new UnsupportedOperationException();
479         }
480
481         @Override
482         public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
483                 throw new UnsupportedOperationException();
484         }
485
486         @Override
487         public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
488                 throw new UnsupportedOperationException();
489         }
490
491         @Override
492         public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
493                 throw new UnsupportedOperationException();
494         }
495
496         @Override
497         public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
498                 throw new UnsupportedOperationException();
499         }
500
501         @Override
502         public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
503                 throw new UnsupportedOperationException();
504         }
505
506         @Override
507         public <T> T sync(ReadInterface<T> r) throws DatabaseException {
508                 throw new UnsupportedOperationException();
509         }
510
511         @Override
512         public <T> T sync(WriteInterface<T> r) throws DatabaseException {
513                 throw new UnsupportedOperationException();
514         }
515         
516         @Override
517         public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
518                 throw new UnsupportedOperationException();
519         }
520
521         @Override
522         public <T> void async(WriteInterface<T> r) {
523                 throw new UnsupportedOperationException();
524         }
525         
526         @Override
527         public Object getModificationCounter() {
528                 throw new UnsupportedOperationException();
529         }
530         
531 }