@Override public Object getBeanId(Object bean) { methodCalls.add(MethodCall.of("getBeanId").with("bean", bean)); return delegate.getBeanId(bean); }
@Override public Map<String, ValuePair> diff(Object a, Object b) { methodCalls.add(MethodCall.of("diff").with("a", a, "b", b)); return delegate.diff(a, b); }
@Override public <T> CsvReader<T> createCsvReader(Class<T> beanType) { methodCalls.add(MethodCall.of("createCsvReader").with("beanType", beanType)); return delegate.createCsvReader(beanType); }
@Override public <T> T execute(TxScope scope, TxCallable<T> callable) { methodCalls.add(MethodCall.of("bulkUpdate").with("scope", scope, "callable", callable)); return delegate.execute(scope, callable); }
@Override public Transaction createTransaction(TxIsolation isolation) { methodCalls.add(MethodCall.of("createTransaction").with("isolation", isolation)); return delegate.createTransaction(isolation); }
@Override public Transaction beginTransaction(TxIsolation isolation) { methodCalls.add(MethodCall.of("beginTransaction").with("isolation", isolation)); return delegate.beginTransaction(isolation); }
@Override public Transaction beginTransaction(TxScope scope) { methodCalls.add(MethodCall.of("beginTransaction").with("scope", scope)); return delegate.beginTransaction(scope); }
@Override public <T> Query<T> createQuery(Class<T> beanType) { methodCalls.add(MethodCall.of("createQuery").with("beanType", beanType)); return delegateQuery.createQuery(beanType); }
@Override public <T> FutureList<T> findFutureList(Query<T> query, Transaction transaction) { methodCalls.add(MethodCall.of("findFutureList").with("query", query, "transaction", transaction)); return find.findFutureList(query, transaction); }
@Override public <T> PagedList<T> findPagedList(Query<T> query, Transaction transaction) { methodCalls.add(MethodCall.of("findPagedList").with("query", query, "transaction", transaction)); return find.findPagedList(query, transaction); }
@Override public <K, T> Map<K, T> findMap(Query<T> query, Transaction transaction) { methodCalls.add(MethodCall.of("findMap").with("query", query, "transaction", transaction)); return find.findMap(query, transaction); }
@Override public Object nextId(Class<?> beanType) { methodCalls.add(MethodCall.of("nextId").with("beanType", beanType)); return !persistSaves ? 0 : save.nextId(beanType); }
@Override public int execute(Update<?> update) { methodCalls.add(MethodCall.of("bulkUpdate").with("update", update)); return !persistBulkUpdates ? 0 : bulkUpdate.execute(update); }
@Override public int execute(CallableSql callableSql) { methodCalls.add(MethodCall.of("bulkUpdate").with("callableSql", callableSql)); return !persistBulkUpdates ? 0 : bulkUpdate.execute(callableSql); }
@Override public SqlUpdate createSqlUpdate(String sql) { methodCalls.add(MethodCall.of("createSqlUpdate").with("sql", sql)); return delegate.createSqlUpdate(sql); }
@Override public SqlQuery createSqlQuery(String sql) { methodCalls.add(MethodCall.of("createSqlQuery").with("sql", sql)); return delegateQuery.createSqlQuery(sql); }
@Override public <T> FutureIds<T> findFutureIds(Query<T> query, Transaction transaction) { methodCalls.add(MethodCall.of("findFutureIds").with("query", query, "transaction", transaction)); return find.findFutureIds(query, transaction); }
@Override public int saveAll(Collection<?> beans, Transaction transaction) throws OptimisticLockException { methodCalls.add(MethodCall.of(SAVE_ALL).with("beans", beans, "transaction", transaction)); capturedBeans.addSavedAll(beans); return !persistSaves ? 0 : save.saveAll(beans, transaction); }
@Override public void insert(Object bean) { methodCalls.add(MethodCall.of(INSERT).with("bean", bean)); capturedBeans.addInserted(bean); if (persistInserts) { save.insert(bean, null); } }
@Override public boolean deletePermanent(Object bean, Transaction transaction) throws OptimisticLockException { methodCalls.add(MethodCall.of(DELETE_PERMANENT).with("bean", bean)); capturedBeans.addDeletePermanent(bean); return !persistDeletes ? true : delete.deletePermanent(bean, transaction); }