@Override public List<T> then(Task<JSONObject> task) throws Exception { JSONObject json = task.getResult(); // Cache the results, unless we are ignoring the cache ParseQuery.CachePolicy policy = state.cachePolicy(); if (policy != null && (policy != ParseQuery.CachePolicy.IGNORE_CACHE)) { ParseKeyValueCache.saveToKeyValueCache(command.getCacheKey(), json.toString()); } long queryReceived = System.nanoTime(); List<T> response = convertFindResponse(state, task.getResult()); long objectsParsed = System.nanoTime(); if (json.has("trace")) { Object serverTrace = json.get("trace"); PLog.d("ParseQuery", String.format("Query pre-processing took %f seconds\n" + "%s\n" + "Client side parsing took %f seconds\n", (querySent - queryStart) / (1000.0f * 1000.0f), serverTrace, (objectsParsed - queryReceived) / (1000.0f * 1000.0f))); } return response; } }, Task.BACKGROUND_EXECUTOR);
public Builder(State state) { className = state.className(); where.putAll(state.constraints()); includes.addAll(state.includes()); selectedKeys = state.selectedKeys() != null ? new HashSet(state.selectedKeys()) : null; limit = state.limit(); skip = state.skip(); order.addAll(state.order()); extraOptions.putAll(state.extraOptions()); trace = state.isTracingEnabled(); cachePolicy = state.cachePolicy(); maxCacheAge = state.maxCacheAge(); isFromLocalDatastore = state.isFromLocalDatastore(); pinName = state.pinName(); ignoreACLs = state.ignoreACLs(); }
@Test public void testDefaults() { ParseQuery.State.Builder<ParseObject> builder = new ParseQuery.State.Builder<>("TestObject"); ParseQuery.State<ParseObject> state = builder.build(); assertEquals("TestObject", state.className()); assertTrue(state.constraints().isEmpty()); assertTrue(state.includes().isEmpty()); assertNull(state.selectedKeys()); assertEquals(-1, state.limit()); assertEquals(0, state.skip()); assertTrue(state.order().isEmpty()); assertTrue(state.extraOptions().isEmpty()); assertFalse(state.isTracingEnabled()); assertEquals(ParseQuery.CachePolicy.IGNORE_CACHE, state.cachePolicy()); assertEquals(Long.MAX_VALUE, state.maxCacheAge()); assertFalse(state.isFromLocalDatastore()); assertNull(state.pinName()); assertFalse(state.ignoreACLs()); }
if (state.cachePolicy() != CachePolicy.CACHE_THEN_NETWORK || state.isFromLocalDatastore()) { task = countAsync(state);
if (state.cachePolicy() != CachePolicy.CACHE_THEN_NETWORK || state.isFromLocalDatastore()) { task = getFirstAsync(state);
/** * Retrieves at most one {@link ParseObject} that satisfies this query from the source in a * background thread. * <p/> * This is preferable to using {@link #getFirst()}, unless your code is already running in a * background thread. * <p/> * <strong>Note:</strong>This mutates the {@code ParseQuery}. * * @param callback callback.done(object, e) is called when the find completes. */ public void getFirstInBackground(final GetCallback<T> callback) { final State<T> state = builder.setLimit(1) .build(); final Task<T> task; if (state.cachePolicy() != CachePolicy.CACHE_THEN_NETWORK || state.isFromLocalDatastore()) { task = getFirstAsync(state); } else { task = doCacheThenNetwork(state, callback, new CacheThenNetworkCallable<T, Task<T>>() { @Override public Task<T> call(State<T> state, ParseUser user, Task<Void> cancellationToken) { return getFirstAsync(state, user, cancellationToken); } }); } ParseTaskUtils.callbackOnMainThreadAsync(task, callback); }
/** * Retrieves a list of {@link ParseObject}s that satisfy this query from the source in a * background thread. * <p/> * This is preferable to using {@link #find()}, unless your code is already running in a * background thread. * * @param callback callback.done(objectList, e) is called when the find completes. */ public void findInBackground(final FindCallback<T> callback) { final State<T> state = builder.build(); final Task<List<T>> task; if (state.cachePolicy() != CachePolicy.CACHE_THEN_NETWORK || state.isFromLocalDatastore()) { task = findAsync(state); } else { task = doCacheThenNetwork(state, callback, new CacheThenNetworkCallable<T, Task<List<T>>>() { @Override public Task<List<T>> call(State<T> state, ParseUser user, Task<Void> cancellationToken) { return findAsync(state, user, cancellationToken); } }); } ParseTaskUtils.callbackOnMainThreadAsync(task, callback); }
@Override public <T extends ParseObject> Task<List<T>> findAsync( final ParseQuery.State<T> state, final ParseUser user, final Task<Void> cancellationToken) { final String sessionToken = user != null ? user.getSessionToken() : null; CommandDelegate<List<T>> callbacks = new CommandDelegate<List<T>>() { @Override public Task<List<T>> runOnNetworkAsync() { return networkController.findAsync(state, sessionToken, cancellationToken); } @Override public Task<List<T>> runFromCacheAsync() { return findFromCacheAsync(state, sessionToken); } }; return runCommandWithPolicyAsync(callbacks, state.cachePolicy()); }
@Override public <T extends ParseObject> Task<Integer> countAsync( final ParseQuery.State<T> state, final ParseUser user, final Task<Void> cancellationToken) { final String sessionToken = user != null ? user.getSessionToken() : null; CommandDelegate<Integer> callbacks = new CommandDelegate<Integer>() { @Override public Task<Integer> runOnNetworkAsync() { return networkController.countAsync(state, sessionToken, cancellationToken); } @Override public Task<Integer> runFromCacheAsync() { return countFromCacheAsync(state, sessionToken); } }; return runCommandWithPolicyAsync(callbacks, state.cachePolicy()); }