This is an automated email from the ASF dual-hosted git repository.
guozhang pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/trunk by this push:
new f324de4 MINOR: Fixed typos in KGroupedTable Javadoc (#4552)
f324de4 is described below
commit f324de45b88a08357061c55ff69610d7b9ceb116
Author: Dmitry Minkovsky <dminkov...@gmail.com>
AuthorDate: Mon Feb 12 19:52:32 2018 -0500
MINOR: Fixed typos in KGroupedTable Javadoc (#4552)
* Fix typo: substractor -> subtractor
* Fix typo: javadoc references deprecated overload
Reviewers: Guozhang Wang <wangg...@gmail.com>
---
.../kafka/streams/kstream/KGroupedTable.java | 42 +++++++++++-----------
1 file changed, 21 insertions(+), 21 deletions(-)
diff --git
a/streams/src/main/java/org/apache/kafka/streams/kstream/KGroupedTable.java
b/streams/src/main/java/org/apache/kafka/streams/kstream/KGroupedTable.java
index 4d2bb29..1916f16 100644
--- a/streams/src/main/java/org/apache/kafka/streams/kstream/KGroupedTable.java
+++ b/streams/src/main/java/org/apache/kafka/streams/kstream/KGroupedTable.java
@@ -210,13 +210,13 @@ public interface KGroupedTable<K, V> {
* The specified {@link Reducer adder} is applied for each update record
and computes a new aggregate using the
* current aggregate (first argument) and the record's value (second
argument) by adding the new record to the
* aggregate.
- * The specified {@link Reducer substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Reducer subtractor} is applied for each "replaced"
record of the original {@link KTable}
* and computes a new aggregate using the current aggregate (first
argument) and the record's value (second
* argument) by "removing" the "replaced" record from the aggregate.
* If there is no current aggregate the {@link Reducer} is not applied and
the new aggregate will be the record's
* value as-is.
* Thus, {@code reduce(Reducer, Reducer, String)} can be used to compute
aggregate functions like sum.
- * For sum, the adder and substractor would work as follows:
+ * For sum, the adder and subtractor would work as follows:
* <pre>{@code
* public class SumAdder implements Reducer<Integer> {
* public Integer apply(Integer currentAgg, Integer newValue) {
@@ -284,13 +284,13 @@ public interface KGroupedTable<K, V> {
* The specified {@link Reducer adder} is applied for each update record
and computes a new aggregate using the
* current aggregate (first argument) and the record's value (second
argument) by adding the new record to the
* aggregate.
- * The specified {@link Reducer substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Reducer subtractor} is applied for each "replaced"
record of the original {@link KTable}
* and computes a new aggregate using the current aggregate (first
argument) and the record's value (second
* argument) by "removing" the "replaced" record from the aggregate.
* If there is no current aggregate the {@link Reducer} is not applied and
the new aggregate will be the record's
* value as-is.
* Thus, {@code reduce(Reducer, Reducer, String)} can be used to compute
aggregate functions like sum.
- * For sum, the adder and substractor would work as follows:
+ * For sum, the adder and subtractor would work as follows:
* <pre>{@code
* public class SumAdder implements Reducer<Integer> {
* public Integer apply(Integer currentAgg, Integer newValue) {
@@ -353,13 +353,13 @@ public interface KGroupedTable<K, V> {
* Each update to the original {@link KTable} results in a two step update
of the result {@link KTable}.
* The specified {@link Reducer adder} is applied for each update record
and computes a new aggregate using the
* current aggregate and the record's value by adding the new record to
the aggregate.
- * The specified {@link Reducer substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Reducer subtractor} is applied for each "replaced"
record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* If there is no current aggregate the {@link Reducer} is not applied and
the new aggregate will be the record's
* value as-is.
* Thus, {@code reduce(Reducer, Reducer, String)} can be used to compute
aggregate functions like sum.
- * For sum, the adder and substractor would work as follows:
+ * For sum, the adder and subtractor would work as follows:
* <pre>{@code
* public class SumAdder implements Reducer<Integer> {
* public Integer apply(Integer currentAgg, Integer newValue) {
@@ -410,13 +410,13 @@ public interface KGroupedTable<K, V> {
* The specified {@link Reducer adder} is applied for each update record
and computes a new aggregate using the
* current aggregate (first argument) and the record's value (second
argument) by adding the new record to the
* aggregate.
- * The specified {@link Reducer substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Reducer subtractor} is applied for each "replaced"
record of the original {@link KTable}
* and computes a new aggregate using the current aggregate (first
argument) and the record's value (second
* argument) by "removing" the "replaced" record from the aggregate.
* If there is no current aggregate the {@link Reducer} is not applied and
the new aggregate will be the record's
* value as-is.
* Thus, {@code reduce(Reducer, Reducer, String)} can be used to compute
aggregate functions like sum.
- * For sum, the adder and substractor would work as follows:
+ * For sum, the adder and subtractor would work as follows:
* <pre>{@code
* public class SumAdder implements Reducer<Integer> {
* public Integer apply(Integer currentAgg, Integer newValue) {
@@ -487,12 +487,12 @@ public interface KGroupedTable<K, V> {
* The specified {@link Aggregator adder} is applied for each update
record and computes a new aggregate using the
* current aggregate (or for the very first record using the intermediate
aggregation result provided via the
* {@link Initializer}) and the record's value by adding the new record to
the aggregate.
- * The specified {@link Aggregator substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Aggregator subtractor} is applied for each
"replaced" record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* Thus, {@code aggregate(Initializer, Aggregator, Aggregator, String)}
can be used to compute aggregate functions
* like sum.
- * For sum, the initializer, adder, and substractor would work as follows:
+ * For sum, the initializer, adder, and subtractor would work as follows:
* <pre>{@code
* // in this example, LongSerde.class must be set as default value serde
in StreamsConfig
* public class SumInitializer implements Initializer<Long> {
@@ -570,12 +570,12 @@ public interface KGroupedTable<K, V> {
* The specified {@link Aggregator adder} is applied for each update
record and computes a new aggregate using the
* current aggregate (or for the very first record using the intermediate
aggregation result provided via the
* {@link Initializer}) and the record's value by adding the new record to
the aggregate.
- * The specified {@link Aggregator substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Aggregator subtractor} is applied for each
"replaced" record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* Thus, {@code aggregate(Initializer, Aggregator, Aggregator, String)}
can be used to compute aggregate functions
* like sum.
- * For sum, the initializer, adder, and substractor would work as follows:
+ * For sum, the initializer, adder, and subtractor would work as follows:
* <pre>{@code
* // in this example, LongSerde.class must be set as default value serde
in StreamsConfig
* public class SumInitializer implements Initializer<Long> {
@@ -641,7 +641,7 @@ public interface KGroupedTable<K, V> {
* Aggregating is a generalization of {@link #reduce(Reducer, Reducer)
combining via reduce(...)} as it,
* for example, allows the result to have a different type than the input
values.
* If the result value type does not match the {@link
StreamsConfig#VALUE_SERDE_CLASS_CONFIG default value
- * serde} you should use {@link #aggregate(Initializer, Aggregator,
Aggregator, Serde)}.
+ * serde} you should use {@link #aggregate(Initializer, Aggregator,
Aggregator, Materialized)}.
* The result is written into a local {@link KeyValueStore} (which is
basically an ever-updating materialized view)
* provided by the given {@code storeSupplier}.
* Furthermore, updates to the store are sent downstream into a {@link
KTable} changelog stream.
@@ -652,12 +652,12 @@ public interface KGroupedTable<K, V> {
* The specified {@link Aggregator adder} is applied for each update
record and computes a new aggregate using the
* current aggregate (or for the very first record using the intermediate
aggregation result provided via the
* {@link Initializer}) and the record's value by adding the new record to
the aggregate.
- * The specified {@link Aggregator substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Aggregator subtractor} is applied for each
"replaced" record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* Thus, {@code aggregate(Initializer, Aggregator, Aggregator, String)}
can be used to compute aggregate functions
* like sum.
- * For sum, the initializer, adder, and substractor would work as follows:
+ * For sum, the initializer, adder, and subtractor would work as follows:
* <pre>{@code
* // in this example, LongSerde.class must be set as default value serde
in StreamsConfig
* public class SumInitializer implements Initializer<Long> {
@@ -720,12 +720,12 @@ public interface KGroupedTable<K, V> {
* The specified {@link Aggregator adder} is applied for each update
record and computes a new aggregate using the
* current aggregate (or for the very first record using the intermediate
aggregation result provided via the
* {@link Initializer}) and the record's value by adding the new record to
the aggregate.
- * The specified {@link Aggregator substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Aggregator subtractor} is applied for each
"replaced" record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* Thus, {@code aggregate(Initializer, Aggregator, Aggregator, String)}
can be used to compute aggregate functions
* like sum.
- * For sum, the initializer, adder, and substractor would work as follows:
+ * For sum, the initializer, adder, and subtractor would work as follows:
* <pre>{@code
* public class SumInitializer implements Initializer<Long> {
* public Long apply() {
@@ -807,12 +807,12 @@ public interface KGroupedTable<K, V> {
* The specified {@link Aggregator adder} is applied for each update
record and computes a new aggregate using the
* current aggregate (or for the very first record using the intermediate
aggregation result provided via the
* {@link Initializer}) and the record's value by adding the new record to
the aggregate.
- * The specified {@link Aggregator substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Aggregator subtractor} is applied for each
"replaced" record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* Thus, {@code aggregate(Initializer, Aggregator, Aggregator, String)}
can be used to compute aggregate functions
* like sum.
- * For sum, the initializer, adder, and substractor would work as follows:
+ * For sum, the initializer, adder, and subtractor would work as follows:
* <pre>{@code
* public class SumInitializer implements Initializer<Long> {
* public Long apply() {
@@ -880,12 +880,12 @@ public interface KGroupedTable<K, V> {
* The specified {@link Aggregator adder} is applied for each update
record and computes a new aggregate using the
* current aggregate (or for the very first record using the intermediate
aggregation result provided via the
* {@link Initializer}) and the record's value by adding the new record to
the aggregate.
- * The specified {@link Aggregator substractor} is applied for each
"replaced" record of the original {@link KTable}
+ * The specified {@link Aggregator subtractor} is applied for each
"replaced" record of the original {@link KTable}
* and computes a new aggregate using the current aggregate and the
record's value by "removing" the "replaced"
* record from the aggregate.
* Thus, {@code aggregate(Initializer, Aggregator, Aggregator, String)}
can be used to compute aggregate functions
* like sum.
- * For sum, the initializer, adder, and substractor would work as follows:
+ * For sum, the initializer, adder, and subtractor would work as follows:
* <pre>{@code
* public class SumInitializer implements Initializer<Long> {
* public Long apply() {
--
To stop receiving notification emails like this one, please contact
guozh...@apache.org.
