com.google.android.agera.Function Java Examples

private void setUpRepository() {
    networkExecutor = Executors.newSingleThreadExecutor();

    mMutableRepository = Repositories.mutableRepository(mPagination);

    mLoadDataRepository = Repositories.repositoryWithInitialValue(Result.<ApiResult<GirlInfo>>absent())
            .observe(mMutableRepository)
            .onUpdatesPerLoop()
            .goTo(networkExecutor)
            .attemptGetFrom(new GirlsSupplier(mMutableRepository)).orSkip()
            .thenTransform(new Function<ApiResult<GirlInfo>, Result<ApiResult<GirlInfo>>>() {
                @NonNull
                @Override
                public Result<ApiResult<GirlInfo>> apply(@NonNull ApiResult<GirlInfo> input) {
                    return absentIfNull(input);
                }
            })
            .onDeactivation(RepositoryConfig.SEND_INTERRUPT)
            .compile();

}
 

@Test
public void shouldBindRepositoryPresenterCollectionOfCollection() {
  final RepositoryPresenter<String> repositoryPresenter =
      repositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .bindWith(binder)
          .bindCollectionWith(collectionBinder)
          .forCollection(new Function<String, List<String>>() {
            @NonNull
            @Override
            public List<String> apply(@NonNull final String input) {
              return singletonList(valueOf(input.charAt(0)));
            }
          });
  repositoryPresenter.bind(STRING, 0, viewHolder);
  verify(binder).bind(FIRST_STRING_CHARACTER, view);
  verify(collectionBinder).bind(STRING, view);
}
 

@Test
public void shouldBindRepositoryPresenterOfCollection() {
  final RepositoryPresenter<String> repositoryPresenter =
      repositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .bindWith(binder)
          .forCollection(new Function<String, List<String>>() {
            @NonNull
            @Override
            public List<String> apply(@NonNull final String input) {
              return singletonList(valueOf(input.charAt(0)));
            }
          });
  repositoryPresenter.bind(STRING, 0, viewHolder);
  verify(binder).bind(FIRST_STRING_CHARACTER, view);
}
 

CompiledRepositoryPresenter(
    @NonNull final Function<Object, Integer> layoutId,
    @NonNull final Binder<Object, View> binder,
    @NonNull final Function<Object, Long> stableIdForItem,
    @NonNull final Receiver<View> recycler,
    @NonNull final Function<Object, Object> keyForItem,
    final boolean detectMoves,
    @NonNull final Function<Object, List<Object>> converter,
    @NonNull final Binder<Object, View> collectionBinder) {
  this.collectionBinder = collectionBinder;
  this.converter = converter;
  this.layoutId = layoutId;
  this.binder = binder;
  this.stableIdForItem = stableIdForItem;
  this.recycler = recycler;
  this.enableDiff = keyForItem != NO_KEY_FOR_ITEM;
  this.keyForItem = keyForItem;
  this.detectMoves = detectMoves;
}
 

@Test
public void shouldBindRepositoryPresenterOfCollection() {
  final RepositoryPresenter<String> repositoryPresenter =
      dataBindingRepositoryPresenterOf(String.class)
          .layout(LAYOUT_ID)
          .itemId(ITEM_ID)
          .forCollection(new Function<String, List<String>>() {
            @NonNull
            @Override
            public List<String> apply(@NonNull final String input) {
              return singletonList(valueOf(input.charAt(0)));
            }
          });
  repositoryPresenter.bind(STRING, 0, viewHolder);

  verify(viewDataBinding).setVariable(ITEM_ID, FIRST_STRING_CHARACTER);
  verify(viewDataBinding).executePendingBindings();
  verifyNoMoreInteractions(viewDataBinding);
}
 

CompiledRepositoryPresenter(
    @NonNull final Function<Object, Integer> itemId,
    @NonNull final Function<Object, Integer> layoutId,
    @NonNull final Function<Object, Long> stableIdForItem,
    @NonNull final SparseArray<Object> handlers,
    final int recycleConfig,
    @NonNull final Function<Object, List<Object>> converter,
    final int collectionId,
    @NonNull final Function<Object, Object> keyForItem,
    final boolean detectMoves) {
  this.itemId = itemId;
  this.collectionId = collectionId;
  this.converter = converter;
  this.layoutId = layoutId;
  this.stableIdForItem = stableIdForItem;
  this.recycleConfig = recycleConfig;
  this.handlers = handlers;
  this.enableDiff = keyForItem != NO_KEY_FOR_ITEM;
  this.keyForItem = keyForItem;
  this.detectMoves = detectMoves;
}
 

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();
}
 

/**
 * 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));
}
 

@NonNull
@Override
public RPMain diffWith(@NonNull final Function keyForItem, final boolean detectMoves) {
  this.keyForItem = keyForItem;
  this.detectMoves = detectMoves;
  return this;
}
 

@NonNull
@Override
public RepositoryPresenter<Result<List>> forResultList() {
  return new CompiledRepositoryPresenter(layoutForItem, binder, stableIdForItem, recycler,
      keyForItem, detectMoves, (Function) resultListAsList(),
      collectionBinder);
}
 

@NonNull
@Override
public RepositoryPresenter<Result> forResult() {
  return new CompiledRepositoryPresenter(layoutForItem, binder, stableIdForItem, recycler,
      keyForItem, detectMoves, (Function) resultAsList(),
      collectionBinder);
}
 

@NonNull
@Override
public RepositoryPresenter<List> forList() {
  return new CompiledRepositoryPresenter(layoutForItem, binder, stableIdForItem, recycler,
      keyForItem, detectMoves, (Function) identityFunction(),
      collectionBinder);
}
 

@NonNull
@Override
public RepositoryPresenter<Result<List<Object>>> forResultList() {
  return new CompiledRepositoryPresenter(itemId, layoutFactory,
      stableIdForItem, handlers, recycleConfig, (Function) resultListAsList(), collectionId,
      keyForItem, detectMoves);
}
 

@NonNull
@Override
public RepositoryPresenter<List<Object>> forList() {
  return new CompiledRepositoryPresenter(itemId, layoutFactory, stableIdForItem,
      handlers, recycleConfig, (Function) identityFunction(), collectionId, keyForItem,
      detectMoves);
}
 

@NonNull
@Override
public DBRPMain diffWith(@NonNull final Function keyForItem, final boolean detectMoves) {
  this.keyForItem = keyForItem;
  this.detectMoves = detectMoves;
  return this;
}
 

@NonNull
static <TRow> RowHandler<TRow> rowBinder(
    @NonNull final RecycledViewPool pool,
    @NonNull final Function<TRow, LayoutManager> layoutManager,
    @NonNull final Function<TRow, Long> stableIdFunction,
    @NonNull final Function<TRow, RepositoryPresenter<TRow>> presenterFromView) {
  return new RowHandler<>(pool, stableIdFunction, presenterFromView, layoutManager);
}
 

private RowHandler(@NonNull final RecycledViewPool pool,
    @NonNull final Function<TRow, Long> stableId,
    @NonNull final Function<TRow, RepositoryPresenter<TRow>> presenter,
    @NonNull final Function<TRow, LayoutManager> layoutManager) {
  this.stableId = checkNotNull(stableId);
  this.presenter = checkNotNull(presenter);
  this.layoutManager = layoutManager;
  this.itemRowStates = new IdentityHashMap<>();
  this.previousStableIds = new IdentityHashMap<>();
  this.adapterRepositories = new IdentityHashMap<>();
  this.startedAdapters = new HashSet<>();
  this.pool = pool;
}
 

@Override protected void initData() {
    SaveVolley saveVolley = SaveVolleys
        .<GankData>request(TEST_URL)
        .method(Method.GET)
        .parseStyle(FASTJSON)
        .classOf(GankData.class)
        .createRequest()
        .context(this)
        .compile();

    final Repository<GankResultData> repository = Repositories
        .repositoryWithInitialValue(INITIAL_VALUE)
        .observe(saveVolley.getReservoir())
        .onUpdatesPerLoop()
        .goTo(executor)
        .attemptGetFrom(saveVolley.getReservoir())
        .orSkip()
        .thenAttemptTransform(new Function<Object, Result<GankResultData>>() {
            /**
             * Returns the result of applying this function to {@code input}.
             */
            @NonNull @Override public Result<GankResultData> apply(@NonNull Object input) {
                if (input instanceof GankData) {
                    return Result.success(((GankData) input).results.get(0));
                } else if (input instanceof VolleyError) {
                    return Result.failure((VolleyError) input);
                }
                return Result.failure();
            }
        })
        .orSkip()
        .compile();

    repository.addUpdatable(new Updatable() {
        @Override public void update() {
            getContentText.setText(repository.get().toString());
        }
    });
}
 

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();
}
 

@Override protected void initData() {
    SaveVolley saveVolley = SaveVolleys
        .<GankData>request(TEST_URL)
        .method(Method.GET)
        .parseStyle(FASTJSON)
        .classOf(GankData.class)
        .createRequest()
        .context(this)
        .compile();

    final Repository<GankResultData> repository = Repositories
        .repositoryWithInitialValue(INITIAL_VALUE)
        .observe(saveVolley.getReservoir())
        .onUpdatesPerLoop()
        .goTo(executor)
        .attemptGetFrom(saveVolley.getReservoir())
        .orSkip()
        .thenAttemptTransform(new Function<Object, Result<GankResultData>>() {
            /**
             * Returns the result of applying this function to {@code input}.
             */
            @NonNull @Override public Result<GankResultData> apply(@NonNull Object input) {
                if (input instanceof GankData) {
                    return Result.success(((GankData) input).results.get(0));
                } else if (input instanceof VolleyError) {
                    return Result.failure((VolleyError) input);
                }
                return Result.failure();
            }
        })
        .orSkip()
        .compile();

    repository.addUpdatable(new Updatable() {
        @Override public void update() {
            getContentText.setText(repository.get().toString());
        }
    });
}
 

@Override protected void initData() {
    SaveVolley saveVolley = SaveVolleys
        .<GankData>request(TEST_URL)
        .method(Method.GET)
        .parseStyle(GSON)
        .classOf(GankData.class)
        .createRequest()
        .context(this)
        .compile();

    final Repository<GankResultData> repository = Repositories
        .repositoryWithInitialValue(INITIAL_VALUE)
        .observe(saveVolley.getReservoir())
        .onUpdatesPerLoop()
        .goTo(executor)
        .attemptGetFrom(saveVolley.getReservoir())
        .orSkip()
        .thenAttemptTransform(new Function<Object, Result<GankResultData>>() {
            /**
             * Returns the result of applying this function to {@code input}.
             */
            @NonNull @Override public Result<GankResultData> apply(@NonNull Object input) {
                if (input instanceof GankData) {
                    return Result.success(((GankData) input).results.get(0));
                } else if (input instanceof VolleyError) {
                    return Result.failure((VolleyError) input);
                }
                return Result.failure();
            }
        })
        .orSkip()
        .compile();

    repository.addUpdatable(new Updatable() {
        @Override public void update() {
            getContentText.setText(repository.get().toString());
        }
    });
}
 

@Override protected void initData() {
    SaveVolley saveVolley = SaveVolleys
        .<GankData>request(TEST_URL)
        .method(Method.GET)
        .parseStyle(GSON)
        .classOf(GankData.class)
        .createRequest()
        .context(this)
        .compile();

    final Repository<GankResultData> repository = Repositories.repositoryWithInitialValue(
        INITIAL_VALUE)
        .observe(saveVolley.getReservoir())
        .onUpdatesPerLoop()
        .goTo(executor)
        .attemptGetFrom(saveVolley.getReservoir())
        .orSkip()
        .thenAttemptTransform(new Function<Object, Result<GankResultData>>() {
            /**
             * Returns the result of applying this function to {@code input}.
             */
            @NonNull @Override public Result<GankResultData> apply(@NonNull Object input) {
                if (input instanceof GankData) {
                    return Result.success(((GankData) input).results.get(0));
                } else if (input instanceof VolleyError) {
                    return Result.failure((VolleyError) input);
                }
                return Result.failure();
            }
        })
        .orSkip()
        .compile();

    repository.addUpdatable(new Updatable() {
        @Override public void update() {
            getContentText.setText(repository.get().toString());
        }
    });
}
 

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();
}
 

/**
 * Creates a default http {@link Function} that returns a {@link Result} with a
 * {@link HttpResponse} from a {@link HttpRequest}.
 */
@NonNull
public static Function<HttpRequest, Result<HttpResponse>> httpFunction() {
  return HTTP_FUNCTION;
}
 

@NonNull
@Override
public RepositoryPresenter<Result<Object>> forResult() {
  return new CompiledRepositoryPresenter(itemId, layoutFactory, stableIdForItem,
      handlers, recycleConfig, (Function) resultAsList(), collectionId, keyForItem, detectMoves);
}
 

private DatabaseQueryMerger(@NonNull final Function<Cursor, T> cursorToItem) {
  this.cursorToItem = checkNotNull(cursorToItem);
}
 

/**
 * 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());
}
 

/**
 * 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());
}
 

@NonNull
@Override
public RepositoryPresenter forCollection(@NonNull final Function converter) {
  return new CompiledRepositoryPresenter(layoutForItem, binder, stableIdForItem, recycler,
      keyForItem, detectMoves, converter, collectionBinder);
}