import com.google.android.agera.Repository; //导入依赖的package包/类
@SuppressWarnings("unchecked") private void prepare() {
    translateReaction = Reservoirs.<Translation>reactionReservoir();
    Repository<Result<String>> translationRepo = repositoryWithInitialValue(
        Result.<String>absent())
        .observe(translateReaction)
        .onUpdatesPerLoop()
        .attemptGetFrom(translateReaction).orSkip()
        .goTo(networkExecutor)
        .check(input -> input.getStep() == OnConfirm)
        .orEnd((Function<Translation, Result<String>>) input -> {
            Log.e("check-confirm", input.toString());
            return Result.failure();
        })
        .mergeIn(YOU_DAO, current2UrlMerger())
        .attemptTransform(urlToResponse())
        .orEnd(Result::failure)
        .goTo(calculationExecutor)
        .transform(youdaoResponseToResult())
        .goLazy()
        .thenTransform(input -> input)
        .onDeactivation(SEND_INTERRUPT)
        .compile();
    translationRepo.addUpdatable(() -> translationRepo.get()
        .ifSucceededSendTo(this::handleConfirm)
        .ifFailedSendTo(errorHandler()));
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@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());
        }
    });
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@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());
        }
    });
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@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());
        }
    });
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@NonNull public static Repository<Result<String>> async(Reservoir<String> reaction) {
    return repositoryWithInitialValue(Result.<String>absent())
        .observe(reaction)
        .onUpdatesPerLoop()
        .attemptGetFrom(reaction).orSkip()
        .goTo(networkExecutor)
        .getFrom(YIN)
        .attemptTransform(urlToResponse())
        .orEnd(Result::failure)
        .goTo(calculationExecutor)
        .thenTransform(yinResponseToResult())
        .onDeactivation(SEND_INTERRUPT)
        .compile();
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@NonNull public static Repository<Result<String>> sync() {
    return repositoryWithInitialValue(Result.<String>absent())
        .observe()
        .onUpdatesPerLoop()
        .getFrom(YIN)
        .attemptTransform(urlToResponse())
        .orEnd(Result::failure)
        .thenTransform(yinResponseToResult())
        .onDeactivation(SEND_INTERRUPT)
        .compile();
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@NonNull public static Repository<Result<String>> async(Reservoir<String> reaction) {
    return repositoryWithInitialValue(Result.<String>absent())
        .observe(reaction)
        .onUpdatesPerLoop()
        .attemptGetFrom(reaction).orSkip()
        .goTo(networkExecutor)
        .getFrom(URL)
        .attemptTransform(urlToResponse())
        .orEnd(Result::failure)
        .goTo(calculationExecutor)
        .thenTransform(mapResponse())
        .onDeactivation(SEND_INTERRUPT)
        .compile();
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@NonNull public static Repository<Result<String>> sync() {
    return repositoryWithInitialValue(Result.<String>absent())
        .observe()
        .onUpdatesPerLoop()
        .getFrom(URL)
        .attemptTransform(urlToResponse())
        .orEnd(Result::failure)
        .thenTransform(mapResponse())
        .onDeactivation(SEND_INTERRUPT)
        .compile();
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override public void prepare() {
    echoReaction = Reservoirs.<String>reactionReservoir();
    Repository<String> echoRepo = repositoryWithInitialValue(empty())
        .observe(echoReaction)
        .onUpdatesPerLoop()
        .thenAttemptGetFrom(echoReaction).orSkip()
        .notifyIf((last, cur) -> !cur.isEmpty())
        .onDeactivation(SEND_INTERRUPT)
        .compile();
    getObservableHelper().addToObservable(echoRepo,
        () -> getService().newInReceiver().accept(echoRepo.get()));
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@Override public void prepare() {
    yinReaction = Reservoirs.<String>reactionReservoir();
    Repository<Result<String>> yinRepo = YinRequests.async(yinReaction);
    getObservableHelper().addToObservable(yinRepo, () -> yinRepo.get()
        .ifSucceededSendTo(getService().newInReceiver())
        .ifFailedSendTo(getService().errorHandler()));
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@Override public void prepare() {
    reaction = Reservoirs.<String>reactionReservoir();
    Repository<Result<String>> sdkRepo = AndroidSDKRequests.async(reaction);
    getObservableHelper().addToObservable(sdkRepo, () -> sdkRepo.get()
        .ifSucceededSendTo(getService().newInReceiver())
        .ifFailedSendTo(getService().errorHandler()));
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
private NotesStore(@NonNull final Repository<List<NoteGroup>> notesRepository,
    @NonNull final Receiver<SqlInsertRequest> insert,
    @NonNull final Receiver<SqlUpdateRequest> update,
    @NonNull final Receiver<SqlDeleteRequest> delete,
    @NonNull final SqlDatabaseSupplier databaseSupplier) {
  this.insert = insert;
  this.update = update;
  this.delete = delete;
  this.notesRepository = notesRepository;
  this.databaseSupplier = databaseSupplier;
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
private RepositoryPart(
    @NonNull final Repository repository,
    @NonNull final RepositoryPresenter presenter) {
  this.repository = repository;
  this.presenter = presenter;
  this.data = repository.get();
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
private MessageStore(@NonNull final Repository<List<Message>> messagesRepository,
                     @NonNull final Receiver<StoreRequest> writeRequestReceiver) {
    this.messagesRepository = messagesRepository;
    this.writeRequestReceiver = writeRequestReceiver;
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@NonNull
public Repository<List<Message>> getSimpleMessagesRepository() {
    return messagesRepository;
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
@NonNull
Repository<List<NoteGroup>> getNotesRepository() {
  return notesRepository;
}
 

import com.google.android.agera.Repository; //导入依赖的package包/类
/**
 * Specifies that the {@link RepositoryAdapter} being built should present the given
 * {@code repository} next (after all previously added repositories, items and static layouts),
 * using the given {@code presenter} for any presentation logic.
 *
 * <p>When the {@code RepositoryAdapter} is active (between {@link #startObserving()} and
 * {@link #stopObserving()}), updates from the {@code repository} will cause the data to be
 * reloaded, and the {@code presenter} may be asked to produce a sequence of fine-grained events
 * capturing the change of data. For mor details, see {@link RepositoryPresenter#getUpdates}.
 *
 * @param repository The repository to be presented. This can be the same as a previously added
 *     repository; this makes the resulting {@link RepositoryAdapter} present the same data in
 *     different positions and/or different ways.
 * @param presenter The repository presenter associated with the {@code repository} at this
 *     position of the {@link RepositoryAdapter}.
 * @return This instance, for chaining.
 */
@NonNull
public <T> Builder add(@NonNull final Repository<T> repository,
    @NonNull final RepositoryPresenter<T> presenter) {
  parts.add(new RepositoryPart(repository, presenter));
  return this;
}