drawers

public class ModularExponent {
  //ModularExponent
  //An implementation of divide-and-conquer method of calculating modular exponents
  //See Introduction to Algorithms, Corment et al.
	
	//tested correct to (a,b,n) = (256,256,256)
	public static int modularExponent(int a, int b, int n) {
		if (a < 0 || b < 0 || n < 0) {
			throw new IllegalArgumentException("Arguments must be positive integers");
		}

drawers

Observable<Games> retrieveGames(String playerName) {
    return playerRepository.retrieve(playerName)
            .flatMap( (player) -> gamesRepository.retrieve(player.id()));
}

drawers

ListenableFuture<Games> retrieveGames(String playerName) {
	return FluentFuture.from(playerRepository.retrieve(playerName))
		.transformAsync( (player) -> gamesRepository.retrieve(player.id()), directExecutor())
}

drawers

class MainPresenter implements MainContract.Presenter { 

    private final PlayerRepository playerRepository;
    private final GamesRepository gamesRepository;
    private final MainContract.View view;

    @Inject
    MainPresenter(PlayerRepository playerRepository, GamesRepository gamesRepository, MainContract.View view) {
        this.playerRepository = playerRepository;
        this.gamesRepository = gamesRepository;

drawers

class MainRequestHelper {

    private final PlayerRepository playerRepository;
    private final GamesRepository gamesRepository;

    @Inject
    public MainRequestHelper(PlayerRepository playerRepository, GamesRepository gamesRepository, StatisticsProcessor statisticsProcessor) {
        this.playerRepository = playerRepository;
        this.gamesRepository = gamesRepository;
    }

drawers

class MainPresenter implements MainContract.Presenter { 

    private final MainRequestHelper mainRequestHelper;
    private final MainContract.View view;

    @Inject
    MainPresenter(MainRequestHelper mainRequestHelper, MainContract.View view) {
        this.mainRequestHelper = mainRequestHelper;
        this.view = view;
    }

drawers

@ProducerModule(includes = { PlayerRepositoryModule.class, GamesRepositoryModule.class, PlayerNameModule.class } )
final class MainRequestModule {

    @Produces
    static ListenableFuture<Player> player(PlayerRepository playerRepository, String playerName) {
        return playerRepository.retrieve(playerName);
    }

    @Produces
    static ListenableFuture<Games> games(GamesRepository gamesRepository, Player player) {

drawers

@ProductionComponent(modules = { MainRequestModule.class, ExecutorModule.class })
interface MainRequestComponent {

    ListenableFuture<Games> games();

}

drawers

void showGames(String playerName) {
	MainRequestComponent component = DaggerMainRequestComponent.builder()
					    .playerNameModule(new PlayerNameModule(playerName))
					    .build();
	ListenableFuture<Games> futureGames = component.games();
	futureGames.addCallback(...) //todo: show games using view
}

drawers

public MainRequestHelper(PlayerRepository playerRepository, GamesRepository gamesRepository, StatisticsProcessor statisticsProcessor) {
    this.playerRepository = playerRepository;
    this.gamesRepository = gamesRepository;
    this.statisticsProcessor = statisticsProcessor;
}

ListenableFuture<Statistics> getStatistics(String username) {
    return FluentFuture.from(playerRepository.retrieve(username))
            .transformAsync( (player) -> gamesRepository.retrieve(player.id()), directExecutor())
            .transform( (games) -> statisticsProcessor.process(games), directExecutor());