com.google.android.agera.Supplier Java Examples

private void setUpRepository() {
    mObservable = new OnClickObservable() {
        @Override
        public void onClick( ) {
            dispatchUpdate();
        }
    };
    Supplier<Result<Integer>> supplier = new Supplier<Result<Integer>>() {
        @NonNull
        @Override
        public Result<Integer> get() {
            return Result.success(MockRandomData.getRandomColor());
        }
    };

    mRepository = Repositories.repositoryWithInitialValue(Result.<Integer>absent())
            .observe(mObservable)
            .onUpdatesPerLoop()
            .thenGetFrom(supplier)
            .compile();
}
 

private void setUpRepository() {
    mExecutor = Executors.newSingleThreadExecutor();
    mReservoir = Reservoirs.reservoir();
    Supplier<Result<Integer>> supplier = new Supplier<Result<Integer>>() {
        @NonNull
        @Override
        public Result<Integer> get() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mReservoir.get();// consume receiver
            return Result.success(++mCount);
        }
    };
    mRepository = Repositories.repositoryWithInitialValue(Result.<Integer>absent())
            .observe(mReservoir)
            .onUpdatesPerLoop()
            .goTo(mExecutor)
            .thenGetFrom(supplier)
            .compile();
}
 

@Test public void responseTypes() {
    Type oBodyClass = new TypeToken<Supplier<Result<String>>>() {}.getType();
    assertThat(factory.get(oBodyClass, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));

    Type oBodyWildcard = new TypeToken<Supplier<Result<? extends String>>>() {}.getType();
    assertThat(factory.get(oBodyWildcard, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));

    Type oBodyGeneric = new TypeToken<Supplier<Result<List<String>>>>() {}.getType();
    assertThat(factory.get(oBodyGeneric, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<List<String>>() {}.getType()));

    Type oResponseClass = new TypeToken<Supplier<Result<Response<String>>>>() {}.getType();
    assertThat(factory.get(oResponseClass, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));

    Type oResponseWildcard
        = new TypeToken<Supplier<Result<Response<? extends String>>>>() {}.getType();
    assertThat(factory.get(oResponseWildcard, NO_ANNOTATIONS, retrofit).responseType(),
        equalTo(new TypeToken<String>() {}.getType()));
}
 

@Test public void noUseResultAsFirstInnerTypeThrows() {
    Type reservoirType = new TypeToken<Supplier<String>>() {}.getType();
    try {
        factory.get(reservoirType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e, hasMessage(containsString(
            "Supplier return type must be parameterized as Supplier<Result<Foo>> or Supplier<Result<? extends Foo>>")));
    }
}
 

@Test public void shouldReturnSuccessWithNullBodyResponse() throws Exception {
    MockResponse mockResponse = new MockResponse().setStatus(STATUS_NO_CONTENT);
    assertNull(mockResponse.getBody());
    server.enqueue(mockResponse);

    Supplier<Result<Response<Void>>> supplier = service.responseOfDeleteXXX();
    Result<Response<Void>> responseResult = supplier.get();
    assertTrue(responseResult.succeeded());

    Response<Void> response = responseResult.get();
    assertEquals(response.code(), 204);
    assertNull(response.body());
}
 

@Test public void shouldReturnAbsentIfNullBody() throws Exception {
    MockResponse mockResponse = new MockResponse().setStatus(STATUS_NO_CONTENT);
    assertNull(mockResponse.getBody());
    server.enqueue(mockResponse);

    Supplier<Result<Void>> supplier = service.deleteXXX();
    Result<Void> result = supplier.get();
    assertTrue(result.isAbsent());
}
 

@Test public void responseFailure() throws Exception {
    server.enqueue(new MockResponse().setSocketPolicy(DISCONNECT_AFTER_REQUEST));

    Supplier<Result<Response<String>>> supplier = service.response();
    try {
        supplier.get().get();
        fail();
    } catch (FailedResultException e) {
        assertThat(e.getCause(), instanceOf(IOException.class));
    }
}
 

@Test public void responseSuccess404() throws Exception {
    server.enqueue(new MockResponse().setResponseCode(404).setBody("error"));

    Supplier<Result<Response<String>>> supplier = service.response();
    try {
        supplier.get().get();
        fail();
    } catch (FailedResultException e) {
        assertThat(e.getCause(), instanceOf(HttpException.class));
        assertThat(e.getCause(), hasMessage(containsString("HTTP 404 Client Error")));
    }
}
 

/**
 * Creates a sql query {@link Function}.
 */
@NonNull
public static <T> Function<SqlRequest, Result<List<T>>> databaseQueryFunction(
    @NonNull final Supplier<Result<SQLiteDatabase>> database,
    @NonNull Function<Cursor, T> rowMap) {
  return new DatabaseFunction<>(database, new DatabaseQueryMerger<>(rowMap));
}
 

@Test public void rawResponseTypeThrows() {
    Type reservoirType = new TypeToken<Supplier<Result<Response>>>() {}.getType();
    try {
        factory.get(reservoirType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e, hasMessage(containsString(
            "Response must be parameterized as Response<Foo> or Response<? extends Foo>")));
    }
}
 

@Test public void rawBodyTypeThrows() {
    Type reservoirType = new TypeToken<Supplier>() {}.getType();
    try {
        factory.get(reservoirType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e, hasMessage(containsString(
            "Supplier return type must be parameterized as Supplier<Result<Foo>> or Supplier<Result<? extends Foo>>")));
    }
}
 

@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Supplier.class) {
        return null;
    }
    if (!(returnType instanceof ParameterizedType)) {
        throw new IllegalStateException("Supplier return type must be parameterized"
            + " as Supplier<Result<Foo>> or Supplier<Result<? extends Foo>>");
    }

    Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType);
    if (getRawType(innerType) != Result.class) {
        throw new IllegalStateException("Supplier return type must be parameterized"
            + " as Supplier<Result<Foo>> or Supplier<Result<? extends Foo>>");
    }
    Type innerTypeOfInnerType = getParameterUpperBound(0, (ParameterizedType) innerType);
    if (getRawType(innerTypeOfInnerType) != Response.class) {
        // Generic type is not Response<T>. Use it for body-only adapter.
        return new BodyCallAdapter(innerTypeOfInnerType);
    }

    // Generic type is Response<T>. Extract T and create the Response version of the adapter.
    if (!(innerTypeOfInnerType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized"
            + " as Response<Foo> or Response<? extends Foo>");
    }
    Type responseType = getParameterUpperBound(0, (ParameterizedType) innerTypeOfInnerType);
    return new ResponseCallAdapter(responseType);
}
 

private void setUpRepository() {
    networkExecutor = Executors.newSingleThreadExecutor();
    mObservable = new OnClickObservable() {
        @Override
        public void onClick( ) {
            dispatchUpdate();
        }
    };

    Supplier<String> imageUriSupplier = new Supplier<String>() {
        @NonNull
        @Override
        public String get() {
            return MockRandomData.getRandomImage();
        }
    };

    mRepository = Repositories.repositoryWithInitialValue(Result.<Bitmap>absent())
            .observe(mObservable)
            .onUpdatesPerLoop()
            .getFrom(imageUriSupplier)
            .goTo(networkExecutor)
            .thenTransform(new Function<String, Result<Bitmap>>() {
                @NonNull
                @Override
                public Result<Bitmap> apply(@NonNull String input) {
                    return new ImageSupplier(input).get();
                }
            })
            .compile();
}
 

private void setUpRepository() {
    networkExecutor = Executors.newSingleThreadExecutor();
    mObservable = new SimpleObservable() { };


    mRepository = Repositories.repositoryWithInitialValue(Result.<List<GirlInfo>>absent())
            .observe(mObservable)
            .onUpdatesPerLoop()
            .goTo(networkExecutor)
            .getFrom(new GirlsSupplier(new Supplier<Integer>() {
                @NonNull
                @Override
                public Integer get() {
                    return mPagination;
                }
            }))
            .thenTransform(new Function<Result<ApiResult<GirlInfo>>, Result<List<GirlInfo>>>() {
                @NonNull
                @Override
                public Result<List<GirlInfo>> apply(@NonNull Result<ApiResult<GirlInfo>> input) {
                    if (input.succeeded() && !input.get().error) {
                        return Result.success(input.get().results);
                    } else {
                        return Result.absent();
                    }
                }
            })
            .onDeactivation(RepositoryConfig.SEND_INTERRUPT)
            .compile();
}
 

private void setUpRepository() {
    networkExecutor = Executors.newSingleThreadExecutor();
    uiExecutor = UiThreadExecutor.newUiThreadExecutor();
    mObservable = new SimpleObservable() { };


    mRepository = Repositories.repositoryWithInitialValue(Result.<ApiResult<GirlInfo>>absent())
            .observe(mObservable)
            .onUpdatesPerLoop()
            //.goTo(uiExecutor)
            .getFrom(new Supplier<Object>() {
                @NonNull
                @Override
                public Object get() {
                    Toast.makeText(RecycleViewActivity.this, "load data begin", Toast.LENGTH_LONG).show();
                    return new Object();
                }
            })
            .goTo(networkExecutor)
            .getFrom(new GirlsSupplier(new Supplier<Integer>() {
                @NonNull
                @Override
                public Integer get() {
                    return mPagination;
                }
            }))

            .goTo(uiExecutor)
            .thenTransform(new Function<Result<ApiResult<GirlInfo>>, Result<ApiResult<GirlInfo>>>() {
                @NonNull
                @Override
                public Result<ApiResult<GirlInfo>> apply(@NonNull Result<ApiResult<GirlInfo>> input) {
                    Toast.makeText(RecycleViewActivity.this, "load data end", Toast.LENGTH_LONG).show();
                    return input;
                }
            })
            .onDeactivation(RepositoryConfig.SEND_INTERRUPT)
            .compile();
}
 

DatabaseFunction(@NonNull final Supplier<Result<SQLiteDatabase>> databaseSupplier,
    @NonNull final Merger<SQLiteDatabase, R, Result<T>>
        databaseWithSqlArgumentMerger) {
  this.databaseSupplier = checkNotNull(databaseSupplier);
  this.databaseWithSqlArgument = checkNotNull(databaseWithSqlArgumentMerger);
}
 

/**
 * Creates a sql update {@link Function}.
 */
@NonNull
public static Function<SqlUpdateRequest, Result<Integer>> databaseUpdateFunction(
    @NonNull final Supplier<Result<SQLiteDatabase>> database) {
  return new DatabaseFunction<>(database, new DatabaseUpdateMerger());
}
 

/**
 * Creates a sql insert {@link Function}.
 */
@NonNull
public static Function<SqlInsertRequest, Result<Long>> databaseInsertFunction(
    @NonNull final Supplier<Result<SQLiteDatabase>> database) {
  return new DatabaseFunction<>(database, new DatabaseInsertMerger());
}
 

/**
 * Creates a sql delete {@link Function}.
 */
@NonNull
public static Function<SqlDeleteRequest, Result<Integer>> databaseDeleteFunction(
    @NonNull final Supplier<Result<SQLiteDatabase>> database) {
  return new DatabaseFunction<>(database, new DatabaseDeleteMerger());
}
 

@NonNull
@Factory
public static <T> Matcher<Supplier<T>> has(@NonNull final T value) {
  return new SupplierGives<>(value);
}
 

@NonNull
@Factory
public static <T> Matcher<Supplier<T>> gives(@NonNull final T value) {
  return new SupplierGives<>(value);
}
 

@Override
protected void describeMismatchSafely(final Supplier<T> supplier,
    final Description description) {
  description.appendText("was ").appendValue(supplier.get());
}
 

@Override
protected boolean matchesSafely(@NonNull final Supplier<T> reference) {
  return value.equals(reference.get());
}
 

@Override
public Supplier<Result<R>> adapt(Call<R> call) {
    return new CallSupplier<R>(call);
}
 

@Override public Supplier<Result<Response<R>>> adapt(Call<R> call) {
    return new CallResponseSupplier<R>(call);
}
 

public GirlsSupplier(@NonNull Supplier<Integer> supplier ) {
    mSupplierPagination = supplier;
}
 

@GET("{page}") Supplier<Result<Response<Gank>>> android(@Path("page") int page); 

@GET("1") Supplier<Result<Gank>> android(); 

@DELETE("/xxx") Supplier<Result<Response<Void>>> responseOfDeleteXXX(); 

@DELETE("/xxx") Supplier<Result<Void>> deleteXXX();