@Override public TemporaryAttachmentId createTemporaryAttachment(final InputStream stream, final long size) { return streamAttachmentStore.putTemporaryAttachment(stream, size).claim(); }
@Override public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return delegate.get(timeout, unit); } }
@Override public void deleteTemporaryAttachment(final TemporaryAttachmentId temporaryAttachmentId) { streamAttachmentStore.deleteTemporaryAttachment(temporaryAttachmentId).recover(new Function<Throwable, Unit>() { @Override public Unit apply(final Throwable t) { log.info("Unable to delete temporary attachment with id " + temporaryAttachmentId, t); return Unit.VALUE; } }).claim(); }
@Override public Option<AttachmentArchive> apply(@Nullable final File temporaryFile) { Preconditions.checkNotNull(temporaryFile, "temporaryFile"); final AttachmentKey attachmentKey = attachmentKeyMapper.fromAttachment(attachment); final com.atlassian.util.concurrent.Function<InputStream, Unit> saveStream = inputStreamFunctionFactory.saveStream(temporaryFile); return attachmentStore.getAttachment(attachmentKey, saveStream).fold(new Function<Throwable, Option<AttachmentArchive>>() { @Override public Option<AttachmentArchive> apply(@Nullable Throwable throwable) { log.debug(String.format("Failed to retrieve attachment with %s while generating attachment index.", attachmentKey), throwable); return Option.none(); } }, new Function<Unit, Option<AttachmentArchive>>() { @Override public Option<AttachmentArchive> apply(@Nullable Unit unit) { return processAttachmentAndCreateIndex(temporaryFile, attachment, issue, maxEntries); } }).claim(); } };
public <B> Promise<B> flatMap(Function<? super T, Promise<B>> function) { return delegate.flatMap(function); }
public <B> Promise<B> map(Function<? super T, ? extends B> function) { return delegate.map(function); }
@Override public Promise<Result<List<Room>>> list() { return toGetAsyncJsonResource(client) .apply(buildUrl("rooms/list")) .map(responseMapper.to(RoomsResponse.class)) .recover(ResourceMapper.<RoomsResponse>handleError()) .map(new Function<Result<RoomsResponse>, Result<List<Room>>>() { @Override public Result<List<Room>> apply(Result<RoomsResponse> result) { if (result.isSuccess()) { return Result.success(result.success().rooms); } else { return result.asError(); } } }); }
public <B> Promise<B> fold(Function<Throwable, ? extends B> handleThrowable, Function<? super T, ? extends B> function) { return delegate.fold(handleThrowable, function); }
@Override public Promise<Boolean> exists(final AttachmentKey attachmentKey) { return primaryStore.exists(attachmentKey).fold(new com.google.common.base.Function<Throwable, Promise<Boolean>>() { @Override public Promise<Boolean> apply(final Throwable ignored) { return secondaryStore.exists(attachmentKey); } }, new com.google.common.base.Function<Boolean, Promise<Boolean>>() { @Override public Promise<Boolean> apply(final Boolean exists) { if (exists) { return Promises.promise(true); } else { return secondaryStore.exists(attachmentKey); } } }).flatMap(Functions.<Promise<Boolean>>identity()); }
private Promise<Map<String, Result<ExpandedRoom>>> expandRoomsForIds(final HipChatAPI hipChatAPI, final Iterable<String> roomIds, final ImmutableMap.Builder<String, Result<ExpandedRoom>> results) { final ImmutableList.Builder<Promise<RoomResult>> builder = ImmutableList .builder(); final boolean usingPersonalToken = hipChatAPI.getTokenType() instanceof HipChatAPI.TokenType.PersonalToken; //Only schedule at most BATCH_SIZE requests for (final String roomId : Iterables.take(BATCH_SIZE, roomIds)) { Promise<Result<ExpandedRoom>> roomPromise = hipChatAPI.rooms() .getRoom(roomId); if (!usingPersonalToken) { roomPromise = roomPromise.map(FILTER_PRIVATE_ROOM); } builder.add(roomPromise.map(toRoomResult(roomId))); } return Promises.when(builder.build()).flatMap(expandRoomBatch(hipChatAPI, roomIds, results)); }
public Promise<T> done(Effect<T> e) { return delegate.done(e); }
@Override public Promise<T> fail(Effect<Throwable> e) { return delegate.fail(e); }
public Promise<T> recover(Function<Throwable, ? extends T> handleThrowable) { return delegate.recover(handleThrowable); }
@Override public <B> Promise<B> flatMap(Function<? super A, ? extends Promise<? extends B>> function) { return delegate().flatMap(function); }