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 import java.util.function.Consumer;
  16
  17 import org.simantics.db.RequestProcessor;
  18 import org.simantics.db.Resource;
  19 import org.simantics.db.Session;
  20 import org.simantics.db.exception.DatabaseException;
  21 import org.simantics.db.procedure.AsyncListener;
  22 import org.simantics.db.procedure.AsyncMultiListener;
  23 import org.simantics.db.procedure.AsyncMultiProcedure;
  24 import org.simantics.db.procedure.AsyncProcedure;
  25 import org.simantics.db.procedure.Listener;
  26 import org.simantics.db.procedure.MultiListener;
  27 import org.simantics.db.procedure.MultiProcedure;
  28 import org.simantics.db.procedure.Procedure;
  29 import org.simantics.db.procedure.SyncListener;
  30 import org.simantics.db.procedure.SyncMultiListener;
  31 import org.simantics.db.procedure.SyncMultiProcedure;
  32 import org.simantics.db.procedure.SyncProcedure;
  33 import org.simantics.db.request.AsyncMultiRead;
  34 import org.simantics.db.request.AsyncRead;
  35 import org.simantics.db.request.DelayedWrite;
  36 import org.simantics.db.request.DelayedWriteResult;
  37 import org.simantics.db.request.ExternalRead;
  38 import org.simantics.db.request.MultiRead;
  39 import org.simantics.db.request.Read;
  40 import org.simantics.db.request.ReadInterface;
  41 import org.simantics.db.request.Write;
  42 import org.simantics.db.request.WriteInterface;
  43 import org.simantics.db.request.WriteOnly;
  44 import org.simantics.db.request.WriteOnlyResult;
  45 import org.simantics.db.request.WriteResult;
  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, Consumer<DatabaseException> callback) {
  61         throw new UnsupportedOperationException();
  62     }
  63
  64     @Override
  65     public void asyncRequest(DelayedWrite request, Consumer<DatabaseException> callback) {
  66         throw new UnsupportedOperationException();
  67     }
  68
  69     @Override
  70     public void asyncRequest(WriteOnly request, Consumer<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 }