From bd123fb8824cc1a554ed1fa4abc2f4331ceaff17 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 13:57:39 +0200 Subject: [PATCH] adding support for most of the methods receiving sample or path as parameter --- streamjs/README.md | 13 ------------- streamjs/streamjs-tests.ts | 23 ++++++++++++++++++++++- streamjs/streamjs.d.ts | 25 +++++++++++++++++++++++-- 3 files changed, 45 insertions(+), 16 deletions(-) diff --git a/streamjs/README.md b/streamjs/README.md index ae3fcfc97a..9428177672 100644 --- a/streamjs/README.md +++ b/streamjs/README.md @@ -4,19 +4,6 @@ Unsupported StreamJS function / method signatures: * Stream(collection) * Stream(string) * Stream.empty() - * filter(sample) * map(path) * flatMap(path) - * sorted(path) - * takeWhile(sample) - * dropWhile(sample) - * min(path) - * max(path) - * sum(path) - * average(path) - * allMatch(sample) - * anyMatch(sample) - * groupingBy(path) - * toMap(path, mergeFunction) - * partitioningBy(sample); * Optional.empty() diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index c5f1ea8624..f83ec69e82 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -22,8 +22,10 @@ var strStream = numStream .limit(100) .sorted() .sort() + .sort("propName") .sorted(comparator) .sort(comparator) + .sorted("propName") .shuffle() .reverse() .distinct() @@ -47,8 +49,11 @@ opt = strStream.min(); opt = strStream.min((s1, s2) => 0); var sum = numStream.sum(); +sum = numStream.sum("foo"); var avg = numStream.average(); +avg = numStream.average("foo"); avg = numStream.avg(); +avg = numStream.avg("foo"); var count = numStream.count(); count = numStream.size(); @@ -78,6 +83,13 @@ elems = myStream .toArray(); //.forEach(s => console.log(s)); +myStream = myStream.takeWhile({name: "foo"}); +myStream = myStream.dropWhile({name: "foo"}); +myStream = myStream.filter({name: "foo"}); +var myResult = myStream.min("name"); +myResult = myStream.max("name"); +var match: boolean = myStream.allMatch({name: "foo"}); +match = myStream.anyMatch({name: "foo"}); numStream.collect({ supplier: () => 0, @@ -88,9 +100,13 @@ numStream.collect({ var groupingResult = myStream.groupBy(lst => lst.name); var elems = groupingResult["hello"].elems; groupingResult = myStream.groupingBy(lst => lst.name); +groupingResult = myStream.groupBy("name"); +groupingResult = myStream.groupingBy("name"); var mappingResult = myStream.toMap(lst => lst.name, (e1, e2) => e2); -console.log(mappingResult["a"]); +var aMappingResult: MyList = mappingResult["a"]; + +mappingResult = myStream.toMap("a"); myStream.toMap(lst => lst.name); @@ -104,6 +120,9 @@ partitionedStrings = strStream.partitioningBy(/^a$/); partitionedStrings = strStream.partitioningBy(5); partitionedStrings = strStream.partitionBy(5); +var partitionedList: MyList[][] = myStream.partitionBy({name : "foo"}); +partitionedList = myStream.partitioningBy({name : "foo"}); + var s: string = numStream.joining(); s = numStream.join(); s = numStream.joining(", "); @@ -131,3 +150,5 @@ optNum.ifPresent(n => console.log(n)); var def: number = optNum.orElse(2); def = optNum.orElseGet(() => 3); def = optNum.orElseThrow("something went wrong"); + + diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index aa2a82e61f..81ed58a82f 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -1,5 +1,5 @@ // Type definitions for streamjs 1.4.0 -// Project: http://streamjs.org/ +// Project: https://github.com/winterbe/streamjs // Definitions by: Bence Eros // Definitions: https://github.com/borisyankov/DefinitelyTyped @@ -15,30 +15,40 @@ declare class Stream { anyMatch(predicate: Stream.Predicate): boolean; anyMatch(regexp: RegExp): boolean; + anyMatch(sample: Stream.Sample): boolean; allMatch(predicate: Stream.Predicate): boolean; allMatch(regexp: RegExp): boolean; + allMatch(sample: Stream.Sample): boolean; average(): number; + average(path: string): number; avg(): number; + avg(path: string): number; collect(collector: Stream.Collector): T; count(): number; distinct(): Stream; dropWhile(predicate: Stream.Predicate): Stream; dropWhile(regexp: RegExp): Stream; + dropWhile(sample: Stream.Sample): Stream; each(consumer: Stream.Consumer): void; filter(predicate: Stream.Predicate): Stream; filter(regexp: RegExp): Stream; + filter(sample: Stream.Sample): Stream; findAny(): Stream.Optional; findFirst(): Stream.Optional; forEach(consumer: Stream.Consumer): void; groupBy(mapper: Stream.Function): Stream.GroupingResult; + groupBy(path: string): Stream.GroupingResult; groupingBy(mapper: Stream.Function): Stream.GroupingResult; + groupingBy(path: string): Stream.GroupingResult; indexBy(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; map (mapper: Stream.Function): Stream; max(): Stream.Optional; max(comparator: Stream.Comparator): Stream.Optional; + max(path: string): Stream.Optional; min(): Stream.Optional; min(comparator: Stream.Comparator): Stream.Optional; + min(path: string): Stream.Optional; noneMatch(predicate: (elem: T) => boolean): boolean; noneMatch(regexp: RegExp): boolean; flatMap (mapper: Stream.Function): Stream; @@ -52,10 +62,12 @@ declare class Stream { limit(limit: number): Stream; partitioningBy(predicate: Stream.Predicate): T[][]; partitionBy(predicate: Stream.Predicate): T[][]; + partitionBy(sample: Stream.Sample): T[][]; partitioningBy(regexp: RegExp): T[][]; partitionBy(regexp: RegExp): T[][]; partitioningBy(size: number): T[][]; partitionBy(size: number): T[][]; + partitioningBy(sample: Stream.Sample): T[][]; peek(consumer: Stream.Consumer): Stream; reduce(identity: T, accumulator: Stream.Accumulator): T; reduce(accumulator: Stream.Accumulator): Stream.Optional; @@ -63,21 +75,30 @@ declare class Stream { size(): number; sorted(): Stream; sorted(comparator: Stream.Comparator): Stream; + sorted(path: string): Stream; sort(): Stream; sort(comparator: Stream.Comparator): Stream; + sort(path: string): Stream; shuffle(): Stream; skip(n: number): Stream; slice(begin, end): Stream; - sum(): T; + sum(): number; + sum(path: string): number; takeWhile(predicate: Stream.Predicate): Stream; takeWhile(regexp: RegExp): Stream; + takeWhile(sample: Stream.Sample): Stream; toArray(): T[]; toList(): T[]; toMap(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; + toMap(path: string, mergeFunction?: Stream.Accumulator): T[]; } declare module Stream { + export interface Sample { + [index: string]: any + } + export interface Accumulator { (e1: T, e2: T): T; }