Java Code Examples for io.reactivex.Flowable#map()

@Override
public Publisher<T> apply(@NonNull Flowable<B> upstream) {
  Flowable<Buffer> unwrapped = upstream.map(unwrap::apply);
  Single<Buffer> aggregated = unwrapped.collect(Buffer::buffer, Buffer::appendBuffer);
  Maybe<T> unmarshalled = aggregated.toMaybe().concatMap(buffer -> {
    if (buffer.length() > 0) {
      try {
        T obj;
        if (mapper != null) {
          JsonParser parser = mapper.getFactory().createParser(buffer.getBytes());
          obj = nonNull(mappedType) ? mapper.readValue(parser, mappedType) :
            mapper.readValue(parser, mappedTypeRef);
        } else {
          obj = getT(buffer, mappedType, mappedTypeRef);
        }
        return Maybe.just(obj);
      } catch (Exception e) {
        return Maybe.error(e);
      }
    } else {
      return Maybe.empty();
    }
  });
  return unmarshalled.toFlowable();
}
 

@Override
public <M> void writeMeasurements(@Nonnull final String bucket,
                                  @Nonnull final String org,
                                  @Nonnull final WritePrecision precision,
                                  @Nonnull final Flowable<M> measurements) {

    Arguments.checkNonEmpty(bucket, "bucket");
    Arguments.checkNonEmpty(org, "organization");
    Arguments.checkNotNull(precision, "precision");
    Arguments.checkNotNull(measurements, "measurements");

    Flowable<BatchWriteData> stream = measurements
            .map(it -> new BatchWriteDataMeasurement(it, precision, options, measurementMapper));

    write(bucket, org, precision, stream);
}
 

/**
 * Quickly produce numbers
 */
@Override
public Flowable<NumbersProto.Number> sendNumbers(Single<NumbersProto.HowMany> request) {
    // Fork the response flowable using share()
    Flowable<Integer> numbers = request
            // Extract request
            .map(NumbersProto.HowMany::getNumber)
            // Process request
            .flatMapPublisher(i -> Flowable.range(0, i))
            .share();

    // One fork updates the UI
    numbers.observeOn(JavaFxScheduler.platform())
            .subscribe(i -> {
                producedLabel.setText(i.toString());
                producedSeries.getData().add(new XYChart.Data<>(System.currentTimeMillis(), i));
            });

    // Other fork returns the number stream
    return numbers.map(BackpressureController::protoNum);
}
 

/**
 * Observe a resource matching the given {@code id}.
 *
 * @param id resource id.
 * @return {@link Flowable} instance.
 * @throws CDAResourceNotFoundException if resource was not found.
 */
@SuppressWarnings("unchecked")
public Flowable<T> one(final String id) {
  Flowable<T> flowable = where("sys.id", id).all()
    .map(array -> {
      if (array.items().size() == 0) {
        throw new CDAResourceNotFoundException(type, id);
      }
      CDAType resourceType = typeForClass(type);
      if (ASSET.equals(resourceType)) {
        return (T) array.assets().get(id);
      } else if (ENTRY.equals(resourceType)) {
        return (T) array.entries().get(id);
      } else if (CONTENTTYPE.equals(resourceType)) {
        return (T) array.items().get(0);
      } else if (LOCALE.equals(resourceType)) {
        T found = findById(array, id);
        if (found == null) {
          throw new CDAResourceNotFoundException(type, id);
        }
        return found;
      } else {
        throw new IllegalArgumentException("Cannot invoke query for type: " + type.getName());
      }
    }
  );

  if (CONTENTTYPE.equals(typeForClass(type))) {
    flowable = flowable.map(t -> {
      if (t != null) {
        client.cache.types().put(t.id(), (CDAContentType) t);
      }
      return t;
    });
  }
  return flowable;
}
 

@Override
public <T> Publisher<CacheResult<T>> flow(RxCache rxCache, final String key, Flowable<T> source, Type type) {
    return source.map(new Function<T, CacheResult<T>>() {
        @Override
        public CacheResult<T> apply(@NonNull T t) throws Exception {
            return new CacheResult<>(ResultFrom.Remote, key, t);
        }
    });
}
 

@Override
public Flowable<Integer> apply(Flowable<Integer> f) throws Exception {
    return f.map(new Function<Integer, Integer>() {

        @Override
        public Integer apply(Integer t) throws Exception {
            return t + 1;
        }
    });
}
 

public static Flowable<String> strings(Flowable<?> source) {
    return source.map(new Function<Object, String>() {
        @Override
        public String apply(Object t) throws Exception {
            return String.valueOf(t);
        }
    });
}
 

/**
 * Ensures that a listener is listening to the logs of a container, from a given time
 **/
@SuppressFBWarnings("RV_RETURN_VALUE_IGNORED")
private void ensureCapturingContainerLogs(Container container, Instant since, LogListener listener) {

	ContainerListener key = new ContainerListener(container, listener);
	Flowable stream = captureStreams.get(key);
	if (stream != null) {
		return;
	}

	List<String> command = getLogCommand(since, listener, container);
	log.debug("Scheduling new log capture flowable for container [{}] and listener [{}], command is [{}]",
			container, listener, Joiner.on(' ').join(command));

	try {
		Process dockerCliProcess = new ProcessBuilder(command.toArray(new String[command.size()])).start();

		Flowable<String> stdOutLines = flowableInputStreamScanner(dockerCliProcess.getInputStream()).subscribeOn(Schedulers.newThread());
		Flowable<String> stdErrLines = flowableInputStreamScanner(dockerCliProcess.getErrorStream()).subscribeOn(Schedulers.newThread());
		Flowable<String> allLines = stdOutLines.mergeWith(stdErrLines);
		Flowable<LogEvent> allEvents = allLines.map(s -> new LogEvent(container.getServiceName(), container.getReplicaNumber(), s));
		allEvents.subscribe(listener::accept, Throwable::printStackTrace, () -> captureStreams.remove(key));
		captureStreams.put(key, allEvents);
	}
	catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

/**
 * @param context   app context 上下文
 * @param password  the wallet password(not the bip39 password) 钱包密码(而不是BIP39的密码)
 * @param mnemonics 助记词
 * @return wallet 钱包
 */
public Flowable<HLWallet> generateWallet(Context context,
                                         String password,
                                         String mnemonics) {
    Flowable<String> flowable = Flowable.just(mnemonics);

    return flowable
            .map(s -> {
                ECKeyPair keyPair = generateKeyPair(s);
                WalletFile walletFile = Wallet.createLight(password, keyPair);
                HLWallet hlWallet = new HLWallet(walletFile);
                WalletManager.shared().saveWallet(context, hlWallet);
                return hlWallet;
            });
}
 

@Override
public void writeRecords(@Nonnull final String bucket,
                         @Nonnull final String org,
                         @Nonnull final WritePrecision precision,
                         @Nonnull final Flowable<String> records) {

    Arguments.checkNonEmpty(bucket, "bucket");
    Arguments.checkNonEmpty(org, "organization");
    Arguments.checkNotNull(precision, "precision");
    Arguments.checkNotNull(records, "records");

    Flowable<BatchWriteData> stream = records.map(BatchWriteDataRecord::new);

    write(bucket, org, precision, stream);
}
 

@Incoming("transactions")
@Outgoing("internal")
public Flowable<Transaction> process(Flowable<String> value) {
    return value.map(s -> jsonb.fromJson(s, Transaction.class));
}
 

@Override
public Flowable<NumberProto.Number> twoWayPressure(Flowable<NumberProto.Number> request) {
    return request.map(x -> kaboom());
}
 

@Override
public Flowable<Message> manyToMany(Flowable<Message> request) {
    return request.map(this::maybeExplode);
}
 

@Outgoing("X")
@Incoming("Z2")
public Flowable<String> y(Flowable<String> z) {
    return z.map(String::toUpperCase);
}
 

@Outgoing("X")
@Incoming("Z2")
public Flowable<String> y(Flowable<String> z) {
    return z.map(String::toUpperCase);
}
 

@Outgoing("X")
@Incoming("Z2")
public Flowable<String> y(Flowable<String> z) {
    return z.map(String::toUpperCase);
}
 

@Test
public void testJsonInputToStateMachineIssue1() throws InterruptedException {

    // JSON source stream (could contain other messages about other
    // Microwaves with different ids which will be processed concurrently by
    // the Processor)
    Flowable<String> messages = Flowable.just(
            "{\"cls\": \"Microwave\", \"id\": \"1\",\"event\": \"ButtonPressed\"}",
            "{\"cls\": \"Microwave\", \"id\": \"1\",\"event\": \"DoorOpened\"}",
            "{\"cls\": \"Microwave\", \"id\": \"1\",\"event\": \"ButtonPressed\"}");

    Flowable<Signal<?, String>> signals = messages //
            .map(msg -> toSignal(msg));

    // special scheduler that we will use to schedule signals and to process
    // events
    Scheduler scheduler = Schedulers.from(Executors.newFixedThreadPool(3));

    // create the signal processor
    Processor<String> processor = createProcessor(scheduler, signals);

    // using a test subscriber because has easy assert methods on it
    TestSubscriber<Object> ts = TestSubscriber.create();

    // subscribe to the stream of entity states that is produced from the
    // signals stream
    processor //
            .flowable() //
            // just output the states
            .map(esm -> esm.state()) //
            .subscribe(ts);

    // wait for processing to finish (is running asynchronously using the
    // scheduler)
    Thread.sleep(1000);

    // assert that things happened as we expected
    ts.assertValues( //
            MicrowaveStateMachine.State.COOKING,
            MicrowaveStateMachine.State.COOKING_INTERRUPTED,
            MicrowaveStateMachine.State.COOKING_INTERRUPTED);

}
 

@PostMapping("/flowable")
public Flowable<Person> transformFlowable(@RequestBody Flowable<Person> persons) {
	return persons.map(person -> new Person(person.getName().toUpperCase()));
}
 

@PostMapping("/flowable")
public Flowable<Person> transformFlowable(@RequestBody Flowable<Person> persons) {
	return persons.map(person -> new Person(person.getName().toUpperCase()));
}