java/src/main/com/google/appengine/api/datastore/DatastoreServiceImpl.java

   1 // Copyright 2007 Google Inc. All rights reserved.
   2
   3 package com.google.appengine.api.datastore;
   4
   5 import static com.google.appengine.api.datastore.FutureHelper.quietGet;
   6
   7 import java.util.Collection;
   8 import java.util.List;
   9 import java.util.Map;
  10
  11 /**
  12  * An implementation of {@link DatastoreService} that farms out all calls to a provided
  13  * {@link AsyncDatastoreService}.
  14  *
  15  */
  16 final class DatastoreServiceImpl implements DatastoreService {
  17
  18   private final AsyncDatastoreServiceInternal async;
  19
  20   public DatastoreServiceImpl(AsyncDatastoreServiceInternal async) {
  21     this.async = async;
  22   }
  23
  24   @Override
  25   public Transaction getCurrentTransaction() {
  26     return async.getCurrentTransaction();
  27   }
  28
  29   @Override
  30   public Transaction getCurrentTransaction(Transaction returnedIfNoTxn) {
  31     return async.getCurrentTransaction(returnedIfNoTxn);
  32   }
  33
  34   @Override
  35   public Entity get(Transaction txn, Key key) throws EntityNotFoundException {
  36     return quietGet(async.get(txn, key), EntityNotFoundException.class);
  37   }
  38
  39   @Override
  40   public Entity get(Key key) throws EntityNotFoundException {
  41     return quietGet(async.get(key), EntityNotFoundException.class);
  42   }
  43
  44   @Override
  45   public Map<Key, Entity> get(Iterable<Key> keys) {
  46     return quietGet(async.get(keys));
  47   }
  48
  49   @Override
  50   public Map<Key, Entity> get(Transaction txn, Iterable<Key> keys) {
  51     return quietGet(async.get(txn, keys));
  52   }
  53
  54   @Override
  55   public Key put(Entity entity) {
  56     return quietGet(async.put(entity));
  57   }
  58
  59   @Override
  60   public Key put(Transaction txn, Entity entity) {
  61     return quietGet(async.put(txn, entity));
  62   }
  63
  64   @Override
  65   public List<Key> put(Iterable<Entity> entities) {
  66     return quietGet(async.put(entities));
  67   }
  68
  69   @Override
  70   public List<Key> put(Transaction txn, Iterable<Entity> entities) {
  71     return quietGet(async.put(txn, entities));
  72   }
  73
  74   @Override
  75   public void delete(Key... keys) {
  76     quietGet(async.delete(keys));
  77   }
  78
  79   @Override
  80   public void delete(Transaction txn, Key... keys) {
  81     quietGet(async.delete(txn, keys));
  82   }
  83
  84   @Override
  85   public void delete(Iterable<Key> keys) {
  86     quietGet(async.delete(keys));
  87   }
  88
  89   @Override
  90   public void delete(Transaction txn, Iterable<Key> keys) {
  91     quietGet(async.delete(txn, keys));
  92   }
  93
  94   @Override
  95   public PreparedQuery prepare(Query query) {
  96     return async.prepare(query);
  97   }
  98
  99   @Override
 100   public PreparedQuery prepare(Transaction txn, Query query) {
 101     return async.prepare(txn, query);
 102   }
 103
 104   @Override
 105   public Collection<Transaction> getActiveTransactions() {
 106     return async.getActiveTransactions();
 107   }
 108
 109   @Override
 110   public KeyRange allocateIds(String kind, long num) {
 111     return quietGet(async.allocateIds(kind, num));
 112   }
 113
 114   @Override
 115   public KeyRange allocateIds(Key parent, String kind, long num) {
 116     return quietGet(async.allocateIds(parent, kind, num));
 117   }
 118
 119   @Override
 120   public KeyRangeState allocateIdRange(KeyRange range) {
 121     return quietGet(async.allocateIdRange(range));
 122   }
 123
 124   @Override
 125   public Transaction beginTransaction() {
 126     return quietGet(async.beginTransaction());
 127   }
 128
 129   @Override
 130   public Transaction beginTransaction(TransactionOptions options) {
 131     return quietGet(async.beginTransaction(options));
 132   }
 133
 134   @Override
 135   public DatastoreAttributes getDatastoreAttributes() {
 136     return quietGet(async.getDatastoreAttributes());
 137   }
 138
 139   @Override
 140   public Map<Index, Index.IndexState> getIndexes() {
 141     return quietGet(async.getIndexes());
 142   }
 143 }