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()); }
state.isFromLocalDatastore()) { task = countAsync(state); } else {
state.isFromLocalDatastore()) { task = getFirstAsync(state); } else {
/** * 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); }
@Test public void testFromPin() { ParseQuery<ParseObject> query = new ParseQuery<>("Test"); Parse.enableLocalDatastore(null); query.fromPin(); // We generate a state to verify the content of the builder ParseQuery.State state = query.getBuilder().build(); assertTrue(state.isFromLocalDatastore()); assertEquals(ParseObject.DEFAULT_PIN, state.pinName()); }
@Override public <T extends ParseObject> Task<List<T>> findAsync( ParseQuery.State<T> state, ParseUser user, Task<Void> cancellationToken) { if (state.isFromLocalDatastore()) { return offlineStore.findFromPinAsync(state.pinName(), state, user); } else { return networkController.findAsync(state, user, cancellationToken); } }
@Override public <T extends ParseObject> Task<Integer> countAsync( ParseQuery.State<T> state, ParseUser user, Task<Void> cancellationToken) { if (state.isFromLocalDatastore()) { return offlineStore.countFromPinAsync(state.pinName(), state, user); } else { return networkController.countAsync(state, user, cancellationToken); } } }