Java 8 Streams C++ port
This is an e implementation of the behaviour of Java 8 Streams.
The idea is to have a stream class that can handle filter, map and collect methods. It should operate over STL containers. And it would let you chain operations in a efficient way by pipelining them.
This STL containers have been tested:
- list
- vector
- set
Cloning
Since this repo is recursive, you need to clone it recursively
git clone --recursive https://github.com/fivunlm/cppstreams.git
If you forgot to do that, you can download the submodules later by running
git submodule update --init --recursive
Hooks
This repo also provides a few simple hooks to make working with submodules easier. While it is not necessary to do this step, it is recommended.
cp -va .hooks/* .git/hooks/
Building
This project uses gradle for building. The nice thing about gradle is that you only need to have Java (and a C++ compiler (Needs support for C++11) of your
choice) installed.
Building is super straight forward:
./gradlew build
This will build the project, all its dependencies and perform the test.
Use the following to just build the project and all its dependencies without performing the tests.
./gradlew assemble
Usage
To use it just create a stream object, it needs two template arguments. First the stream contained object type, then the original container type. here is an example using a list of ints:
Stream<int, std::list<int> > oStream(testList);
or you can just use makeStream static method:
Stream<int, std::list<int> >::makeStream(testList)
Then chain as many map and/or filter as needed:
oStream.filter([](const int &iValue) { return iValue % 2 == 0; })
.map([](const int &iValue) { return iValue * 2; })
.map([](const int &iValue) { return iValue + 3; })
And finally use the method collect. It receives an optional limit parameter to get a restricted set of the original list
.collect()
collect will return a new list with the applied functions.
There are all the methods available
Method | Desc |
---|---|
filter(<lambda_expression>) | Filter stream elements |
map(<lambda_expression>) | Transforms stream elements |
collect(limit = 0) | Process pipelined stream operations and return first limit elements |
sum(startValue = 0) | Accumulate the objects of the stream |
findFirst(<lambda_expression>) | Returns the first element |
There are several other methods like sum to accumulate the objects of the stream, findFirst to find first occurrence given a predicate. And more are coming.
Motivation
For the full story check this Medium post.
TODO
There are a lot of things still to do:
- Test it with containers of complex objects and structs
- Add reduce method
- Add forEach
- Add findAny
- Infinite streams
- Performance analysis